1package eu.siacs.conversations.parser;
   2
   3import android.util.Log;
   4import android.util.Pair;
   5
   6import com.cheogram.android.BobTransfer;
   7import com.cheogram.android.WebxdcUpdate;
   8
   9import java.io.File;
  10import java.net.URISyntaxException;
  11import java.text.SimpleDateFormat;
  12import java.util.ArrayList;
  13import java.util.Arrays;
  14import java.util.Collections;
  15import java.util.Date;
  16import java.util.LinkedHashSet;
  17import java.util.List;
  18import java.util.Locale;
  19import java.util.Map;
  20import java.util.Set;
  21import java.util.UUID;
  22
  23import io.ipfs.cid.Cid;
  24
  25import eu.siacs.conversations.Config;
  26import eu.siacs.conversations.R;
  27import eu.siacs.conversations.crypto.axolotl.AxolotlService;
  28import eu.siacs.conversations.crypto.axolotl.BrokenSessionException;
  29import eu.siacs.conversations.crypto.axolotl.NotEncryptedForThisDeviceException;
  30import eu.siacs.conversations.crypto.axolotl.OutdatedSenderException;
  31import eu.siacs.conversations.crypto.axolotl.XmppAxolotlMessage;
  32import eu.siacs.conversations.entities.Account;
  33import eu.siacs.conversations.entities.Bookmark;
  34import eu.siacs.conversations.entities.Contact;
  35import eu.siacs.conversations.entities.Conversation;
  36import eu.siacs.conversations.entities.Conversational;
  37import eu.siacs.conversations.entities.Message;
  38import eu.siacs.conversations.entities.MucOptions;
  39import eu.siacs.conversations.entities.ReadByMarker;
  40import eu.siacs.conversations.entities.ReceiptRequest;
  41import eu.siacs.conversations.entities.RtpSessionStatus;
  42import eu.siacs.conversations.http.HttpConnectionManager;
  43import eu.siacs.conversations.services.MessageArchiveService;
  44import eu.siacs.conversations.services.QuickConversationsService;
  45import eu.siacs.conversations.services.XmppConnectionService;
  46import eu.siacs.conversations.utils.CryptoHelper;
  47import eu.siacs.conversations.xml.Element;
  48import eu.siacs.conversations.xml.LocalizedContent;
  49import eu.siacs.conversations.xml.Namespace;
  50import eu.siacs.conversations.xmpp.InvalidJid;
  51import eu.siacs.conversations.xmpp.Jid;
  52import eu.siacs.conversations.xmpp.OnMessagePacketReceived;
  53import eu.siacs.conversations.xmpp.chatstate.ChatState;
  54import eu.siacs.conversations.xmpp.jingle.JingleConnectionManager;
  55import eu.siacs.conversations.xmpp.jingle.JingleRtpConnection;
  56import eu.siacs.conversations.xmpp.pep.Avatar;
  57import eu.siacs.conversations.xmpp.stanzas.MessagePacket;
  58
  59public class MessageParser extends AbstractParser implements OnMessagePacketReceived {
  60
  61    private static final SimpleDateFormat TIME_FORMAT = new SimpleDateFormat("HH:mm:ss", Locale.ENGLISH);
  62
  63    private static final List<String> JINGLE_MESSAGE_ELEMENT_NAMES = Arrays.asList("accept", "propose", "proceed", "reject", "retract");
  64
  65    public MessageParser(XmppConnectionService service) {
  66        super(service);
  67    }
  68
  69    private static String extractStanzaId(Element packet, boolean isTypeGroupChat, Conversation conversation) {
  70        final Jid by;
  71        final boolean safeToExtract;
  72        if (isTypeGroupChat) {
  73            by = conversation.getJid().asBareJid();
  74            safeToExtract = conversation.getMucOptions().hasFeature(Namespace.STANZA_IDS);
  75        } else {
  76            Account account = conversation.getAccount();
  77            by = account.getJid().asBareJid();
  78            safeToExtract = account.getXmppConnection().getFeatures().stanzaIds();
  79        }
  80        return safeToExtract ? extractStanzaId(packet, by) : null;
  81    }
  82
  83    private static String extractStanzaId(Account account, Element packet) {
  84        final boolean safeToExtract = account.getXmppConnection().getFeatures().stanzaIds();
  85        return safeToExtract ? extractStanzaId(packet, account.getJid().asBareJid()) : null;
  86    }
  87
  88    private static String extractStanzaId(Element packet, Jid by) {
  89        for (Element child : packet.getChildren()) {
  90            if (child.getName().equals("stanza-id")
  91                    && Namespace.STANZA_IDS.equals(child.getNamespace())
  92                    && by.equals(InvalidJid.getNullForInvalid(child.getAttributeAsJid("by")))) {
  93                return child.getAttribute("id");
  94            }
  95        }
  96        return null;
  97    }
  98
  99    private static Jid getTrueCounterpart(Element mucUserElement, Jid fallback) {
 100        final Element item = mucUserElement == null ? null : mucUserElement.findChild("item");
 101        Jid result = item == null ? null : InvalidJid.getNullForInvalid(item.getAttributeAsJid("jid"));
 102        return result != null ? result : fallback;
 103    }
 104
 105    private boolean extractChatState(Conversation c, final boolean isTypeGroupChat, final MessagePacket packet) {
 106        ChatState state = ChatState.parse(packet);
 107        if (state != null && c != null) {
 108            final Account account = c.getAccount();
 109            final Jid from = packet.getFrom();
 110            if (from.asBareJid().equals(account.getJid().asBareJid())) {
 111                c.setOutgoingChatState(state);
 112                if (state == ChatState.ACTIVE || state == ChatState.COMPOSING) {
 113                    if (c.getContact().isSelf()) {
 114                        return false;
 115                    }
 116                    mXmppConnectionService.markRead(c);
 117                    activateGracePeriod(account);
 118                }
 119                return false;
 120            } else {
 121                if (isTypeGroupChat) {
 122                    MucOptions.User user = c.getMucOptions().findUserByFullJid(from);
 123                    if (user != null) {
 124                        return user.setChatState(state);
 125                    } else {
 126                        return false;
 127                    }
 128                } else {
 129                    return c.setIncomingChatState(state);
 130                }
 131            }
 132        }
 133        return false;
 134    }
 135
 136    private Message parseAxolotlChat(Element axolotlMessage, Jid from, Conversation conversation, int status, final boolean checkedForDuplicates, boolean postpone) {
 137        final AxolotlService service = conversation.getAccount().getAxolotlService();
 138        final XmppAxolotlMessage xmppAxolotlMessage;
 139        try {
 140            xmppAxolotlMessage = XmppAxolotlMessage.fromElement(axolotlMessage, from.asBareJid());
 141        } catch (Exception e) {
 142            Log.d(Config.LOGTAG, conversation.getAccount().getJid().asBareJid() + ": invalid omemo message received " + e.getMessage());
 143            return null;
 144        }
 145        if (xmppAxolotlMessage.hasPayload()) {
 146            final XmppAxolotlMessage.XmppAxolotlPlaintextMessage plaintextMessage;
 147            try {
 148                plaintextMessage = service.processReceivingPayloadMessage(xmppAxolotlMessage, postpone);
 149            } catch (BrokenSessionException e) {
 150                if (checkedForDuplicates) {
 151                    if (service.trustedOrPreviouslyResponded(from.asBareJid())) {
 152                        service.reportBrokenSessionException(e, postpone);
 153                        return new Message(conversation, "", Message.ENCRYPTION_AXOLOTL_FAILED, status);
 154                    } else {
 155                        Log.d(Config.LOGTAG, "ignoring broken session exception because contact was not trusted");
 156                        return new Message(conversation, "", Message.ENCRYPTION_AXOLOTL_FAILED, status);
 157                    }
 158                } else {
 159                    Log.d(Config.LOGTAG, "ignoring broken session exception because checkForDuplicates failed");
 160                    return null;
 161                }
 162            } catch (NotEncryptedForThisDeviceException e) {
 163                return new Message(conversation, "", Message.ENCRYPTION_AXOLOTL_NOT_FOR_THIS_DEVICE, status);
 164            } catch (OutdatedSenderException e) {
 165                return new Message(conversation, "", Message.ENCRYPTION_AXOLOTL_FAILED, status);
 166            }
 167            if (plaintextMessage != null) {
 168                Message finishedMessage = new Message(conversation, plaintextMessage.getPlaintext(), Message.ENCRYPTION_AXOLOTL, status);
 169                finishedMessage.setFingerprint(plaintextMessage.getFingerprint());
 170                Log.d(Config.LOGTAG, AxolotlService.getLogprefix(finishedMessage.getConversation().getAccount()) + " Received Message with session fingerprint: " + plaintextMessage.getFingerprint());
 171                return finishedMessage;
 172            }
 173        } else {
 174            Log.d(Config.LOGTAG, conversation.getAccount().getJid().asBareJid() + ": received OMEMO key transport message");
 175            service.processReceivingKeyTransportMessage(xmppAxolotlMessage, postpone);
 176        }
 177        return null;
 178    }
 179
 180    private Invite extractInvite(Element message) {
 181        final Element mucUser = message.findChild("x", Namespace.MUC_USER);
 182        if (mucUser != null) {
 183            Element invite = mucUser.findChild("invite");
 184            if (invite != null) {
 185                String password = mucUser.findChildContent("password");
 186                Jid from = InvalidJid.getNullForInvalid(invite.getAttributeAsJid("from"));
 187                Jid room = InvalidJid.getNullForInvalid(message.getAttributeAsJid("from"));
 188                if (room == null) {
 189                    return null;
 190                }
 191                return new Invite(room, password, false, from);
 192            }
 193        }
 194        final Element conference = message.findChild("x", "jabber:x:conference");
 195        if (conference != null) {
 196            Jid from = InvalidJid.getNullForInvalid(message.getAttributeAsJid("from"));
 197            Jid room = InvalidJid.getNullForInvalid(conference.getAttributeAsJid("jid"));
 198            if (room == null) {
 199                return null;
 200            }
 201            return new Invite(room, conference.getAttribute("password"), true, from);
 202        }
 203        return null;
 204    }
 205
 206    private void parseEvent(final Element event, final Jid from, final Account account) {
 207        final Element items = event.findChild("items");
 208        final String node = items == null ? null : items.getAttribute("node");
 209        if ("urn:xmpp:avatar:metadata".equals(node)) {
 210            Avatar avatar = Avatar.parseMetadata(items);
 211            if (avatar != null) {
 212                avatar.owner = from.asBareJid();
 213                if (mXmppConnectionService.getFileBackend().isAvatarCached(avatar)) {
 214                    if (account.getJid().asBareJid().equals(from)) {
 215                        if (account.setAvatar(avatar.getFilename())) {
 216                            mXmppConnectionService.databaseBackend.updateAccount(account);
 217                            mXmppConnectionService.notifyAccountAvatarHasChanged(account);
 218                        }
 219                        mXmppConnectionService.getAvatarService().clear(account);
 220                        mXmppConnectionService.updateConversationUi();
 221                        mXmppConnectionService.updateAccountUi();
 222                    } else {
 223                        final Contact contact = account.getRoster().getContact(from);
 224                        contact.setAvatar(avatar);
 225                        mXmppConnectionService.syncRoster(account);
 226                        mXmppConnectionService.getAvatarService().clear(contact);
 227                        mXmppConnectionService.updateConversationUi();
 228                        mXmppConnectionService.updateRosterUi();
 229                    }
 230                } else if (mXmppConnectionService.isDataSaverDisabled()) {
 231                    mXmppConnectionService.fetchAvatar(account, avatar);
 232                }
 233            }
 234        } else if (Namespace.NICK.equals(node)) {
 235            final Element i = items.findChild("item");
 236            final String nick = i == null ? null : i.findChildContent("nick", Namespace.NICK);
 237            if (nick != null) {
 238                setNick(account, from, nick);
 239            }
 240        } else if (AxolotlService.PEP_DEVICE_LIST.equals(node)) {
 241            Element item = items.findChild("item");
 242            Set<Integer> deviceIds = mXmppConnectionService.getIqParser().deviceIds(item);
 243            Log.d(Config.LOGTAG, AxolotlService.getLogprefix(account) + "Received PEP device list " + deviceIds + " update from " + from + ", processing... ");
 244            final AxolotlService axolotlService = account.getAxolotlService();
 245            axolotlService.registerDevices(from, deviceIds);
 246        } else if (Namespace.BOOKMARKS.equals(node) && account.getJid().asBareJid().equals(from)) {
 247            if (account.getXmppConnection().getFeatures().bookmarksConversion()) {
 248                final Element i = items.findChild("item");
 249                final Element storage = i == null ? null : i.findChild("storage", Namespace.BOOKMARKS);
 250                Map<Jid, Bookmark> bookmarks = Bookmark.parseFromStorage(storage, account);
 251                mXmppConnectionService.processBookmarksInitial(account, bookmarks, true);
 252                Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": processing bookmark PEP event");
 253            } else {
 254                Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": ignoring bookmark PEP event because bookmark conversion was not detected");
 255            }
 256        } else if (Namespace.BOOKMARKS2.equals(node) && account.getJid().asBareJid().equals(from)) {
 257            final Element item = items.findChild("item");
 258            final Element retract = items.findChild("retract");
 259            if (item != null) {
 260                final Bookmark bookmark = Bookmark.parseFromItem(item, account);
 261                if (bookmark != null) {
 262                    account.putBookmark(bookmark);
 263                    mXmppConnectionService.processModifiedBookmark(bookmark);
 264                    mXmppConnectionService.updateConversationUi();
 265                }
 266            }
 267            if (retract != null) {
 268                final Jid id = InvalidJid.getNullForInvalid(retract.getAttributeAsJid("id"));
 269                if (id != null) {
 270                    account.removeBookmark(id);
 271                    Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": deleted bookmark for " + id);
 272                    mXmppConnectionService.processDeletedBookmark(account, id);
 273                    mXmppConnectionService.updateConversationUi();
 274                }
 275            }
 276        } else {
 277            Log.d(Config.LOGTAG, account.getJid().asBareJid() + " received pubsub notification for node=" + node);
 278        }
 279    }
 280
 281    private void parseDeleteEvent(final Element event, final Jid from, final Account account) {
 282        final Element delete = event.findChild("delete");
 283        final String node = delete == null ? null : delete.getAttribute("node");
 284        if (Namespace.NICK.equals(node)) {
 285            Log.d(Config.LOGTAG, "parsing nick delete event from " + from);
 286            setNick(account, from, null);
 287        } else if (Namespace.BOOKMARKS2.equals(node) && account.getJid().asBareJid().equals(from)) {
 288            account.setBookmarks(Collections.emptyMap());
 289            Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": deleted bookmarks node");
 290        } else if (Namespace.AVATAR_METADATA.equals(node) && account.getJid().asBareJid().equals(from)) {
 291            Log.d(Config.LOGTAG,account.getJid().asBareJid()+": deleted avatar metadata node");
 292        }
 293    }
 294
 295    private void parsePurgeEvent(final Element event, final Jid from, final Account account) {
 296        final Element purge = event.findChild("purge");
 297        final String node = purge == null ? null : purge.getAttribute("node");
 298        if (Namespace.BOOKMARKS2.equals(node) && account.getJid().asBareJid().equals(from)) {
 299            account.setBookmarks(Collections.emptyMap());
 300            Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": purged bookmarks");
 301        }
 302    }
 303
 304    private void setNick(Account account, Jid user, String nick) {
 305        if (user.asBareJid().equals(account.getJid().asBareJid())) {
 306            account.setDisplayName(nick);
 307            if (QuickConversationsService.isQuicksy()) {
 308                mXmppConnectionService.getAvatarService().clear(account);
 309            }
 310        } else {
 311            Contact contact = account.getRoster().getContact(user);
 312            if (contact.setPresenceName(nick)) {
 313                mXmppConnectionService.syncRoster(account);
 314                mXmppConnectionService.getAvatarService().clear(contact);
 315            }
 316        }
 317        mXmppConnectionService.updateConversationUi();
 318        mXmppConnectionService.updateAccountUi();
 319    }
 320
 321    private boolean handleErrorMessage(final Account account, final MessagePacket packet) {
 322        if (packet.getType() == MessagePacket.TYPE_ERROR) {
 323            if (packet.fromServer(account)) {
 324                final Pair<MessagePacket, Long> forwarded = packet.getForwardedMessagePacket("received", Namespace.CARBONS);
 325                if (forwarded != null) {
 326                    return handleErrorMessage(account, forwarded.first);
 327                }
 328            }
 329            final Jid from = packet.getFrom();
 330            final String id = packet.getId();
 331            if (from != null && id != null) {
 332                if (id.startsWith(JingleRtpConnection.JINGLE_MESSAGE_PROPOSE_ID_PREFIX)) {
 333                    final String sessionId = id.substring(JingleRtpConnection.JINGLE_MESSAGE_PROPOSE_ID_PREFIX.length());
 334                    mXmppConnectionService.getJingleConnectionManager()
 335                            .updateProposedSessionDiscovered(account, from, sessionId, JingleConnectionManager.DeviceDiscoveryState.FAILED);
 336                    return true;
 337                }
 338                if (id.startsWith(JingleRtpConnection.JINGLE_MESSAGE_PROCEED_ID_PREFIX)) {
 339                    final String sessionId = id.substring(JingleRtpConnection.JINGLE_MESSAGE_PROCEED_ID_PREFIX.length());
 340                    final String message = extractErrorMessage(packet);
 341                    mXmppConnectionService.getJingleConnectionManager().failProceed(account, from, sessionId, message);
 342                    return true;
 343                }
 344                mXmppConnectionService.markMessage(account,
 345                        from.asBareJid(),
 346                        id,
 347                        Message.STATUS_SEND_FAILED,
 348                        extractErrorMessage(packet));
 349                final Element error = packet.findChild("error");
 350                final boolean pingWorthyError = error != null && (error.hasChild("not-acceptable") || error.hasChild("remote-server-timeout") || error.hasChild("remote-server-not-found"));
 351                if (pingWorthyError) {
 352                    Conversation conversation = mXmppConnectionService.find(account, from);
 353                    if (conversation != null && conversation.getMode() == Conversational.MODE_MULTI) {
 354                        if (conversation.getMucOptions().online()) {
 355                            Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": received ping worthy error for seemingly online muc at " + from);
 356                            mXmppConnectionService.mucSelfPingAndRejoin(conversation);
 357                        }
 358                    }
 359                }
 360            }
 361            return true;
 362        }
 363        return false;
 364    }
 365
 366    @Override
 367    public void onMessagePacketReceived(Account account, MessagePacket original) {
 368        if (handleErrorMessage(account, original)) {
 369            return;
 370        }
 371        final MessagePacket packet;
 372        Long timestamp = null;
 373        boolean isCarbon = false;
 374        String serverMsgId = null;
 375        final Element fin = original.findChild("fin", MessageArchiveService.Version.MAM_0.namespace);
 376        if (fin != null) {
 377            mXmppConnectionService.getMessageArchiveService().processFinLegacy(fin, original.getFrom());
 378            return;
 379        }
 380        final Element result = MessageArchiveService.Version.findResult(original);
 381        final String queryId = result == null ? null : result.getAttribute("queryid");
 382        final MessageArchiveService.Query query = queryId == null ? null : mXmppConnectionService.getMessageArchiveService().findQuery(queryId);
 383        if (query != null && query.validFrom(original.getFrom())) {
 384            final Pair<MessagePacket, Long> f = original.getForwardedMessagePacket("result", query.version.namespace);
 385            if (f == null) {
 386                return;
 387            }
 388            timestamp = f.second;
 389            packet = f.first;
 390            serverMsgId = result.getAttribute("id");
 391            query.incrementMessageCount();
 392            if (handleErrorMessage(account, packet)) {
 393                return;
 394            }
 395        } else if (query != null) {
 396            Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": received mam result with invalid from (" + original.getFrom() + ") or queryId (" + queryId + ")");
 397            return;
 398        } else if (original.fromServer(account)) {
 399            Pair<MessagePacket, Long> f;
 400            f = original.getForwardedMessagePacket("received", Namespace.CARBONS);
 401            f = f == null ? original.getForwardedMessagePacket("sent", Namespace.CARBONS) : f;
 402            packet = f != null ? f.first : original;
 403            if (handleErrorMessage(account, packet)) {
 404                return;
 405            }
 406            timestamp = f != null ? f.second : null;
 407            isCarbon = f != null;
 408        } else {
 409            packet = original;
 410        }
 411
 412        if (timestamp == null) {
 413            timestamp = AbstractParser.parseTimestamp(original, AbstractParser.parseTimestamp(packet));
 414        }
 415        final Element mucUserElement = packet.findChild("x", Namespace.MUC_USER);
 416        final String pgpEncrypted = packet.findChildContent("x", "jabber:x:encrypted");
 417        Element replaceElement = packet.findChild("replace", "urn:xmpp:message-correct:0");
 418        Set<Message.FileParams> attachments = new LinkedHashSet<>();
 419        for (Element child : packet.getChildren()) {
 420            // SIMS first so they get preference in the set
 421            if (child.getName().equals("reference") && child.getNamespace().equals("urn:xmpp:reference:0")) {
 422                if (child.findChild("media-sharing", "urn:xmpp:sims:1") != null) {
 423                    attachments.add(new Message.FileParams(child));
 424                }
 425            }
 426        }
 427        for (Element child : packet.getChildren()) {
 428            if (child.getName().equals("x") && child.getNamespace().equals(Namespace.OOB)) {
 429                attachments.add(new Message.FileParams(child));
 430            }
 431        }
 432        String replacementId = replaceElement == null ? null : replaceElement.getAttribute("id");
 433        if (replacementId == null) {
 434            final Element fasten = packet.findChild("apply-to", "urn:xmpp:fasten:0");
 435            if (fasten != null) {
 436                replaceElement = fasten.findChild("retract", "urn:xmpp:message-retract:0");
 437                if (replaceElement == null) replaceElement = fasten.findChild("moderated", "urn:xmpp:message-moderate:0");
 438                if (replaceElement != null) {
 439                    final String reason = replaceElement.findChildContent("reason", "urn:xmpp:message-moderate:0");
 440                    replacementId = fasten.getAttribute("id");
 441                    packet.setBody(reason == null ? "" : reason);
 442                }
 443            }
 444        }
 445        LocalizedContent body = packet.getBody();
 446
 447        final Element axolotlEncrypted = packet.findChildEnsureSingle(XmppAxolotlMessage.CONTAINERTAG, AxolotlService.PEP_PREFIX);
 448        int status;
 449        final Jid counterpart;
 450        final Jid to = packet.getTo();
 451        final Jid from = packet.getFrom();
 452        final Element originId = packet.findChild("origin-id", Namespace.STANZA_IDS);
 453        final String remoteMsgId;
 454        if (originId != null && originId.getAttribute("id") != null) {
 455            remoteMsgId = originId.getAttribute("id");
 456        } else {
 457            remoteMsgId = packet.getId();
 458        }
 459        boolean notify = false;
 460
 461        Element html = packet.findChild("html", "http://jabber.org/protocol/xhtml-im");
 462        if (html != null && html.findChild("body", "http://www.w3.org/1999/xhtml") == null) {
 463            html = null;
 464        }
 465
 466        if (from == null || !InvalidJid.isValid(from) || !InvalidJid.isValid(to)) {
 467            Log.e(Config.LOGTAG, "encountered invalid message from='" + from + "' to='" + to + "'");
 468            return;
 469        }
 470
 471        boolean isTypeGroupChat = packet.getType() == MessagePacket.TYPE_GROUPCHAT;
 472        if (query != null && !query.muc() && isTypeGroupChat) {
 473            Log.e(Config.LOGTAG, account.getJid().asBareJid() + ": received groupchat (" + from + ") message on regular MAM request. skipping");
 474            return;
 475        }
 476        boolean isMucStatusMessage = InvalidJid.hasValidFrom(packet) && from.isBareJid() && mucUserElement != null && mucUserElement.hasChild("status");
 477        boolean selfAddressed;
 478        if (packet.fromAccount(account)) {
 479            status = Message.STATUS_SEND;
 480            selfAddressed = to == null || account.getJid().asBareJid().equals(to.asBareJid());
 481            if (selfAddressed) {
 482                counterpart = from;
 483            } else {
 484                counterpart = to != null ? to : account.getJid();
 485            }
 486        } else {
 487            status = Message.STATUS_RECEIVED;
 488            counterpart = from;
 489            selfAddressed = false;
 490        }
 491
 492        final Invite invite = extractInvite(packet);
 493        if (invite != null) {
 494            if (isTypeGroupChat) {
 495                Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": ignoring invite to " + invite.jid + " because type=groupchat");
 496            } else if (invite.direct && (mucUserElement != null || invite.inviter == null || mXmppConnectionService.isMuc(account, invite.inviter))) {
 497                Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": ignoring direct invite to " + invite.jid + " because it was received in MUC");
 498            } else {
 499                invite.execute(account);
 500                return;
 501            }
 502        }
 503
 504        final Element reactions = packet.findChild("reactions", "urn:xmpp:reactions:0");
 505        if (body == null && html == null) {
 506            if (reactions != null && reactions.getAttribute("id") != null) {
 507                final Conversation conversation = mXmppConnectionService.find(account, counterpart.asBareJid());
 508                if (conversation != null) {
 509                    final Message reactionTo = conversation.findMessageWithRemoteIdAndCounterpart(reactions.getAttribute("id"), null);
 510                    if (reactionTo != null) {
 511                        String bodyS = reactionTo.reply().getBody();
 512                        for (Element el : reactions.getChildren()) {
 513                            if (el.getName().equals("reaction") && el.getNamespace().equals("urn:xmpp:reactions:0")) {
 514                                bodyS += el.getContent();
 515                            }
 516                        }
 517                        body = new LocalizedContent(bodyS, "en", 1);
 518                        final Message previousReaction = conversation.findMessageReactingTo(reactions.getAttribute("id"), counterpart);
 519                        if (previousReaction != null) replacementId = previousReaction.replyId();
 520                    }
 521                }
 522            }
 523        }
 524
 525        final boolean conversationIsProbablyMuc = isTypeGroupChat || mucUserElement != null || account.getXmppConnection().getMucServersWithholdAccount().contains(counterpart.getDomain().toEscapedString());
 526        final Element webxdc = packet.findChild("x", "urn:xmpp:webxdc:0");
 527        if (webxdc != null) {
 528            final Conversation conversation = mXmppConnectionService.findOrCreateConversation(account, counterpart.asBareJid(), conversationIsProbablyMuc, false, query, false);
 529            Jid webxdcSender = counterpart.asBareJid();
 530            if (conversation.getMode() == Conversation.MODE_MULTI) {
 531                if(conversation.getMucOptions().nonanonymous()) {
 532                    webxdcSender = conversation.getMucOptions().getTrueCounterpart(counterpart);
 533                } else {
 534                    webxdcSender = counterpart;
 535                }
 536            }
 537            mXmppConnectionService.insertWebxdcUpdate(new WebxdcUpdate(
 538                conversation,
 539                remoteMsgId,
 540                counterpart,
 541                packet.findChild("thread"),
 542                body == null ? null : body.content,
 543                webxdc.findChildContent("document", "urn:xmpp:webxdc:0"),
 544                webxdc.findChildContent("summary", "urn:xmpp:webxdc:0"),
 545                webxdc.findChildContent("json", "urn:xmpp:json:0")
 546            ));
 547
 548            mXmppConnectionService.updateConversationUi();
 549        }
 550
 551        if ((body != null || pgpEncrypted != null || (axolotlEncrypted != null && axolotlEncrypted.hasChild("payload")) || !attachments.isEmpty() || html != null) && !isMucStatusMessage) {
 552            final Conversation conversation = mXmppConnectionService.findOrCreateConversation(account, counterpart.asBareJid(), conversationIsProbablyMuc, false, query, false);
 553            final boolean conversationMultiMode = conversation.getMode() == Conversation.MODE_MULTI;
 554
 555            if (serverMsgId == null) {
 556                serverMsgId = extractStanzaId(packet, isTypeGroupChat, conversation);
 557            }
 558
 559
 560            if (selfAddressed) {
 561                if (mXmppConnectionService.markMessage(conversation, remoteMsgId, Message.STATUS_SEND_RECEIVED, serverMsgId)) {
 562                    return;
 563                }
 564                status = Message.STATUS_RECEIVED;
 565                if (remoteMsgId != null && conversation.findMessageWithRemoteId(remoteMsgId, counterpart) != null) {
 566                    return;
 567                }
 568            }
 569
 570            if (isTypeGroupChat) {
 571                if (conversation.getMucOptions().isSelf(counterpart)) {
 572                    status = Message.STATUS_SEND_RECEIVED;
 573                    isCarbon = true; //not really carbon but received from another resource
 574                    if (mXmppConnectionService.markMessage(conversation, remoteMsgId, status, serverMsgId, body)) {
 575                        return;
 576                    } else if (remoteMsgId == null || Config.IGNORE_ID_REWRITE_IN_MUC) {
 577                        if (body != null) {
 578                            Message message = conversation.findSentMessageWithBody(body.content);
 579                            if (message != null) {
 580                                mXmppConnectionService.markMessage(message, status);
 581                                return;
 582                            }
 583                        }
 584                    }
 585                } else {
 586                    status = Message.STATUS_RECEIVED;
 587                }
 588            }
 589            final Message message;
 590            if (pgpEncrypted != null && Config.supportOpenPgp()) {
 591                message = new Message(conversation, pgpEncrypted, Message.ENCRYPTION_PGP, status);
 592            } else if (axolotlEncrypted != null && Config.supportOmemo()) {
 593                Jid origin;
 594                Set<Jid> fallbacksBySourceId = Collections.emptySet();
 595                if (conversationMultiMode) {
 596                    final Jid fallback = conversation.getMucOptions().getTrueCounterpart(counterpart);
 597                    origin = getTrueCounterpart(query != null ? mucUserElement : null, fallback);
 598                    if (origin == null) {
 599                        try {
 600                            fallbacksBySourceId = account.getAxolotlService().findCounterpartsBySourceId(XmppAxolotlMessage.parseSourceId(axolotlEncrypted));
 601                        } catch (IllegalArgumentException e) {
 602                            //ignoring
 603                        }
 604                    }
 605                    if (origin == null && fallbacksBySourceId.size() == 0) {
 606                        Log.d(Config.LOGTAG, "axolotl message in anonymous conference received and no possible fallbacks");
 607                        return;
 608                    }
 609                } else {
 610                    fallbacksBySourceId = Collections.emptySet();
 611                    origin = from;
 612                }
 613
 614                final boolean liveMessage = query == null && !isTypeGroupChat && mucUserElement == null;
 615                final boolean checkedForDuplicates = liveMessage || (serverMsgId != null && remoteMsgId != null && !conversation.possibleDuplicate(serverMsgId, remoteMsgId));
 616
 617                if (origin != null) {
 618                    message = parseAxolotlChat(axolotlEncrypted, origin, conversation, status, checkedForDuplicates, query != null);
 619                } else {
 620                    Message trial = null;
 621                    for (Jid fallback : fallbacksBySourceId) {
 622                        trial = parseAxolotlChat(axolotlEncrypted, fallback, conversation, status, checkedForDuplicates && fallbacksBySourceId.size() == 1, query != null);
 623                        if (trial != null) {
 624                            Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": decoded muc message using fallback");
 625                            origin = fallback;
 626                            break;
 627                        }
 628                    }
 629                    message = trial;
 630                }
 631                if (message == null) {
 632                    if (query == null && extractChatState(mXmppConnectionService.find(account, counterpart.asBareJid()), isTypeGroupChat, packet)) {
 633                        mXmppConnectionService.updateConversationUi();
 634                    }
 635                    if (query != null && status == Message.STATUS_SEND && remoteMsgId != null) {
 636                        Message previouslySent = conversation.findSentMessageWithUuid(remoteMsgId);
 637                        if (previouslySent != null && previouslySent.getServerMsgId() == null && serverMsgId != null) {
 638                            previouslySent.setServerMsgId(serverMsgId);
 639                            mXmppConnectionService.databaseBackend.updateMessage(previouslySent, false);
 640                            Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": encountered previously sent OMEMO message without serverId. updating...");
 641                        }
 642                    }
 643                    return;
 644                }
 645                if (conversationMultiMode) {
 646                    message.setTrueCounterpart(origin);
 647                }
 648            } else if (body == null && !attachments.isEmpty()) {
 649                message = new Message(conversation, "", Message.ENCRYPTION_NONE, status);
 650            } else {
 651                message = new Message(conversation, body == null ? "HTML-only message" : body.content, Message.ENCRYPTION_NONE, status);
 652                if (body != null && body.count > 1) {
 653                    message.setBodyLanguage(body.language);
 654                }
 655            }
 656
 657            Element addresses = packet.findChild("addresses", "http://jabber.org/protocol/address");
 658            if (status == Message.STATUS_RECEIVED && addresses != null) {
 659                for (Element address : addresses.getChildren()) {
 660                    if (!address.getName().equals("address") || !address.getNamespace().equals("http://jabber.org/protocol/address")) continue;
 661
 662                    if (address.getAttribute("type").equals("ofrom") && address.getAttribute("jid") != null) {
 663                        Jid ofrom = address.getAttributeAsJid("jid");
 664                        if (InvalidJid.isValid(ofrom) && ofrom.getDomain().equals(counterpart.getDomain()) &&
 665                            conversation.getAccount().getRoster().getContact(counterpart.getDomain()).getPresences().anySupport("http://jabber.org/protocol/address")) {
 666
 667                            message.setTrueCounterpart(ofrom);
 668                        }
 669                    }
 670                }
 671            }
 672
 673            if (html != null) message.addPayload(html);
 674            message.setSubject(packet.findChildContent("subject"));
 675            message.setCounterpart(counterpart);
 676            message.setRemoteMsgId(remoteMsgId);
 677            message.setServerMsgId(serverMsgId);
 678            message.setCarbon(isCarbon);
 679            message.setTime(timestamp);
 680            if (!attachments.isEmpty()) {
 681                message.setFileParams(attachments.iterator().next());
 682                if (CryptoHelper.isPgpEncryptedUrl(message.getFileParams().url)) {
 683                    message.setEncryption(Message.ENCRYPTION_DECRYPTED);
 684                }
 685            }
 686            message.markable = packet.hasChild("markable", "urn:xmpp:chat-markers:0");
 687            if (reactions != null) message.addPayload(reactions);
 688            for (Element el : packet.getChildren()) {
 689                if ((el.getName().equals("query") && el.getNamespace().equals("http://jabber.org/protocol/disco#items") && el.getAttribute("node").equals("http://jabber.org/protocol/commands")) ||
 690                    (el.getName().equals("fallback") && el.getNamespace().equals("urn:xmpp:fallback:0"))) {
 691                    message.addPayload(el);
 692                }
 693                if (el.getName().equals("thread") && (el.getNamespace() == null || el.getNamespace().equals("jabber:client"))) {
 694                    el.setAttribute("xmlns", "jabber:client");
 695                    message.addPayload(el);
 696                }
 697                if (el.getName().equals("reply") && el.getNamespace() != null && el.getNamespace().equals("urn:xmpp:reply:0")) {
 698                    message.addPayload(el);
 699                }
 700                if (el.getName().equals("attention") && el.getNamespace() != null && el.getNamespace().equals("urn:xmpp:attention:0")) {
 701                    message.addPayload(el);
 702                }
 703            }
 704            if (conversationMultiMode) {
 705                message.setMucUser(conversation.getMucOptions().findUserByFullJid(counterpart));
 706                final Jid fallback = conversation.getMucOptions().getTrueCounterpart(counterpart);
 707                Jid trueCounterpart;
 708                if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL) {
 709                    trueCounterpart = message.getTrueCounterpart();
 710                } else if (query != null && query.safeToExtractTrueCounterpart()) {
 711                    trueCounterpart = getTrueCounterpart(mucUserElement, fallback);
 712                } else {
 713                    trueCounterpart = fallback;
 714                }
 715                if (trueCounterpart != null && isTypeGroupChat) {
 716                    if (trueCounterpart.asBareJid().equals(account.getJid().asBareJid())) {
 717                        status = isTypeGroupChat ? Message.STATUS_SEND_RECEIVED : Message.STATUS_SEND;
 718                    } else {
 719                        status = Message.STATUS_RECEIVED;
 720                        message.setCarbon(false);
 721                    }
 722                }
 723                message.setStatus(status);
 724                message.setTrueCounterpart(trueCounterpart);
 725                if (!isTypeGroupChat) {
 726                    message.setType(Message.TYPE_PRIVATE);
 727                }
 728            } else {
 729                updateLastseen(account, from);
 730            }
 731
 732            if (replacementId != null && mXmppConnectionService.allowMessageCorrection()) {
 733                final Message replacedMessage = conversation.findMessageWithRemoteIdAndCounterpart(replacementId, counterpart);
 734                if (replacedMessage != null) {
 735                    final boolean fingerprintsMatch = replacedMessage.getFingerprint() == null
 736                            || replacedMessage.getFingerprint().equals(message.getFingerprint());
 737                    final boolean trueCountersMatch = replacedMessage.getTrueCounterpart() != null
 738                            && message.getTrueCounterpart() != null
 739                            && replacedMessage.getTrueCounterpart().asBareJid().equals(message.getTrueCounterpart().asBareJid());
 740                    final boolean mucUserMatches = query == null && replacedMessage.sameMucUser(message); //can not be checked when using mam
 741                    final boolean duplicate = conversation.hasDuplicateMessage(message);
 742                    if (fingerprintsMatch && (trueCountersMatch || !conversationMultiMode || mucUserMatches || counterpart.isBareJid()) && !duplicate) {
 743                        Log.d(Config.LOGTAG, "replaced message '" + replacedMessage.getBody() + "' with '" + message.getBody() + "'");
 744                        synchronized (replacedMessage) {
 745                            final String uuid = replacedMessage.getUuid();
 746                            replacedMessage.setUuid(UUID.randomUUID().toString());
 747                            replacedMessage.setBody(message.getBody());
 748                            replacedMessage.setSubject(message.getSubject());
 749                            replacedMessage.setThread(message.getThread());
 750                            replacedMessage.putEdited(replacedMessage.getRemoteMsgId(), replacedMessage.getServerMsgId());
 751                            replacedMessage.setRemoteMsgId(remoteMsgId);
 752                            if (replaceElement != null && !replaceElement.getName().equals("replace")) {
 753                                mXmppConnectionService.getFileBackend().deleteFile(replacedMessage);
 754                                mXmppConnectionService.evictPreview(message.getUuid());
 755                                replacedMessage.clearPayloads();
 756                                replacedMessage.setFileParams(null);
 757                                replacedMessage.setDeleted(true);
 758                                replacedMessage.addPayload(replaceElement);
 759                            }
 760                            if (replacedMessage.getServerMsgId() == null || message.getServerMsgId() != null) {
 761                                replacedMessage.setServerMsgId(message.getServerMsgId());
 762                            }
 763                            replacedMessage.setEncryption(message.getEncryption());
 764                            if (replacedMessage.getStatus() == Message.STATUS_RECEIVED) {
 765                                replacedMessage.markUnread();
 766                            }
 767                            extractChatState(mXmppConnectionService.find(account, counterpart.asBareJid()), isTypeGroupChat, packet);
 768                            mXmppConnectionService.updateMessage(replacedMessage, uuid);
 769                            if (mXmppConnectionService.confirmMessages()
 770                                    && replacedMessage.getStatus() == Message.STATUS_RECEIVED
 771                                    && (replacedMessage.trusted() || replacedMessage.isPrivateMessage()) //TODO do we really want to send receipts for all PMs?
 772                                    && remoteMsgId != null
 773                                    && !selfAddressed
 774                                    && !isTypeGroupChat) {
 775                                processMessageReceipts(account, packet, remoteMsgId, query);
 776                            }
 777                            if (replacedMessage.getEncryption() == Message.ENCRYPTION_PGP) {
 778                                conversation.getAccount().getPgpDecryptionService().discard(replacedMessage);
 779                                conversation.getAccount().getPgpDecryptionService().decrypt(replacedMessage, false);
 780                            }
 781                        }
 782                        mXmppConnectionService.getNotificationService().updateNotification();
 783                        return;
 784                    } else {
 785                        Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": received message correction but verification didn't check out");
 786                    }
 787                } else if (message.getBody() == null || message.getBody().equals("") || message.getBody().equals(" ")) {
 788                    return;
 789                }
 790            }
 791
 792            long deletionDate = mXmppConnectionService.getAutomaticMessageDeletionDate();
 793            if (deletionDate != 0 && message.getTimeSent() < deletionDate) {
 794                Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": skipping message from " + message.getCounterpart().toString() + " because it was sent prior to our deletion date");
 795                return;
 796            }
 797
 798            boolean checkForDuplicates = (isTypeGroupChat && packet.hasChild("delay", "urn:xmpp:delay"))
 799                    || message.isPrivateMessage()
 800                    || message.getServerMsgId() != null
 801                    || (query == null && mXmppConnectionService.getMessageArchiveService().isCatchupInProgress(conversation));
 802            if (checkForDuplicates) {
 803                final Message duplicate = conversation.findDuplicateMessage(message);
 804                if (duplicate != null) {
 805                    final boolean serverMsgIdUpdated;
 806                    if (duplicate.getStatus() != Message.STATUS_RECEIVED
 807                            && duplicate.getUuid().equals(message.getRemoteMsgId())
 808                            && duplicate.getServerMsgId() == null
 809                            && message.getServerMsgId() != null) {
 810                        duplicate.setServerMsgId(message.getServerMsgId());
 811                        if (mXmppConnectionService.databaseBackend.updateMessage(duplicate, false)) {
 812                            serverMsgIdUpdated = true;
 813                        } else {
 814                            serverMsgIdUpdated = false;
 815                            Log.e(Config.LOGTAG, "failed to update message");
 816                        }
 817                    } else {
 818                        serverMsgIdUpdated = false;
 819                    }
 820                    Log.d(Config.LOGTAG, "skipping duplicate message with " + message.getCounterpart() + ". serverMsgIdUpdated=" + serverMsgIdUpdated);
 821                    return;
 822                }
 823            }
 824
 825            if (query != null && query.getPagingOrder() == MessageArchiveService.PagingOrder.REVERSE) {
 826                conversation.prepend(query.getActualInThisQuery(), message);
 827            } else {
 828                conversation.add(message);
 829            }
 830            if (query != null) {
 831                query.incrementActualMessageCount();
 832            }
 833
 834            if (query == null || query.isCatchup()) { //either no mam or catchup
 835                if (status == Message.STATUS_SEND || status == Message.STATUS_SEND_RECEIVED) {
 836                    mXmppConnectionService.markRead(conversation);
 837                    if (query == null) {
 838                        activateGracePeriod(account);
 839                    }
 840                } else {
 841                    message.markUnread();
 842                    notify = true;
 843                }
 844            }
 845
 846            if (message.getEncryption() == Message.ENCRYPTION_PGP) {
 847                notify = conversation.getAccount().getPgpDecryptionService().decrypt(message, notify);
 848            } else if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL_NOT_FOR_THIS_DEVICE || message.getEncryption() == Message.ENCRYPTION_AXOLOTL_FAILED) {
 849                notify = false;
 850            }
 851
 852            if (query == null) {
 853                extractChatState(mXmppConnectionService.find(account, counterpart.asBareJid()), isTypeGroupChat, packet);
 854                mXmppConnectionService.updateConversationUi();
 855            }
 856
 857            if (mXmppConnectionService.confirmMessages()
 858                    && message.getStatus() == Message.STATUS_RECEIVED
 859                    && (message.trusted() || message.isPrivateMessage())
 860                    && remoteMsgId != null
 861                    && !selfAddressed
 862                    && !isTypeGroupChat) {
 863                processMessageReceipts(account, packet, remoteMsgId, query);
 864            }
 865
 866            if (message.getFileParams() != null) {
 867                for (Cid cid : message.getFileParams().getCids()) {
 868                    File f = mXmppConnectionService.getFileForCid(cid);
 869                    if (f != null && f.canRead()) {
 870                        message.setRelativeFilePath(f.getAbsolutePath());
 871                        mXmppConnectionService.getFileBackend().updateFileParams(message, null, false);
 872                        break;
 873                    }
 874                }
 875            }
 876
 877            mXmppConnectionService.databaseBackend.createMessage(message);
 878
 879            final HttpConnectionManager manager = this.mXmppConnectionService.getHttpConnectionManager();
 880            if (message.getRelativeFilePath() == null && message.trusted() && message.treatAsDownloadable() && manager.getAutoAcceptFileSize() > 0) {
 881                if (message.getOob() != null && message.getOob().getScheme().equalsIgnoreCase("cid")) {
 882                    try {
 883                        BobTransfer transfer = new BobTransfer.ForMessage(message, mXmppConnectionService);
 884                        message.setTransferable(transfer);
 885                        transfer.start();
 886                    } catch (URISyntaxException e) {
 887                        Log.d(Config.LOGTAG, "BobTransfer failed to parse URI");
 888                    }
 889                } else {
 890                    manager.createNewDownloadConnection(message);
 891                }
 892            } else if (notify) {
 893                if (query != null && query.isCatchup()) {
 894                    mXmppConnectionService.getNotificationService().pushFromBacklog(message);
 895                } else {
 896                    mXmppConnectionService.getNotificationService().push(message);
 897                }
 898            }
 899        } else if (!packet.hasChild("body")) { //no body
 900
 901            final Conversation conversation = mXmppConnectionService.find(account, from.asBareJid());
 902            if (axolotlEncrypted != null) {
 903                Jid origin;
 904                if (conversation != null && conversation.getMode() == Conversation.MODE_MULTI) {
 905                    final Jid fallback = conversation.getMucOptions().getTrueCounterpart(counterpart);
 906                    origin = getTrueCounterpart(query != null ? mucUserElement : null, fallback);
 907                    if (origin == null) {
 908                        Log.d(Config.LOGTAG, "omemo key transport message in anonymous conference received");
 909                        return;
 910                    }
 911                } else if (isTypeGroupChat) {
 912                    return;
 913                } else {
 914                    origin = from;
 915                }
 916                try {
 917                    final XmppAxolotlMessage xmppAxolotlMessage = XmppAxolotlMessage.fromElement(axolotlEncrypted, origin.asBareJid());
 918                    account.getAxolotlService().processReceivingKeyTransportMessage(xmppAxolotlMessage, query != null);
 919                    Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": omemo key transport message received from " + origin);
 920                } catch (Exception e) {
 921                    Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": invalid omemo key transport message received " + e.getMessage());
 922                    return;
 923                }
 924            }
 925
 926            if (query == null && extractChatState(mXmppConnectionService.find(account, counterpart.asBareJid()), isTypeGroupChat, packet)) {
 927                mXmppConnectionService.updateConversationUi();
 928            }
 929
 930            if (isTypeGroupChat) {
 931                if (packet.hasChild("subject")) { //TODO usually we would want to check for lack of body; however some servers do set a body :(
 932                    if (conversation != null && conversation.getMode() == Conversation.MODE_MULTI) {
 933                        conversation.setHasMessagesLeftOnServer(conversation.countMessages() > 0);
 934                        final LocalizedContent subject = packet.findInternationalizedChildContentInDefaultNamespace("subject");
 935                        if (subject != null && conversation.getMucOptions().setSubject(subject.content)) {
 936                            mXmppConnectionService.updateConversation(conversation);
 937                        }
 938                        mXmppConnectionService.updateConversationUi();
 939                        return;
 940                    }
 941                }
 942            }
 943            if (conversation != null && mucUserElement != null && InvalidJid.hasValidFrom(packet) && from.isBareJid()) {
 944                for (Element child : mucUserElement.getChildren()) {
 945                    if ("status".equals(child.getName())) {
 946                        try {
 947                            int code = Integer.parseInt(child.getAttribute("code"));
 948                            if ((code >= 170 && code <= 174) || (code >= 102 && code <= 104)) {
 949                                mXmppConnectionService.fetchConferenceConfiguration(conversation);
 950                                break;
 951                            }
 952                        } catch (Exception e) {
 953                            //ignored
 954                        }
 955                    } else if ("item".equals(child.getName())) {
 956                        MucOptions.User user = AbstractParser.parseItem(conversation, child);
 957                        Log.d(Config.LOGTAG, account.getJid() + ": changing affiliation for "
 958                                + user.getRealJid() + " to " + user.getAffiliation() + " in "
 959                                + conversation.getJid().asBareJid());
 960                        if (!user.realJidMatchesAccount()) {
 961                            boolean isNew = conversation.getMucOptions().updateUser(user);
 962                            mXmppConnectionService.getAvatarService().clear(conversation);
 963                            mXmppConnectionService.updateMucRosterUi();
 964                            mXmppConnectionService.updateConversationUi();
 965                            Contact contact = user.getContact();
 966                            if (!user.getAffiliation().ranks(MucOptions.Affiliation.MEMBER)) {
 967                                Jid jid = user.getRealJid();
 968                                List<Jid> cryptoTargets = conversation.getAcceptedCryptoTargets();
 969                                if (cryptoTargets.remove(user.getRealJid())) {
 970                                    Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": removed " + jid + " from crypto targets of " + conversation.getName());
 971                                    conversation.setAcceptedCryptoTargets(cryptoTargets);
 972                                    mXmppConnectionService.updateConversation(conversation);
 973                                }
 974                            } else if (isNew
 975                                    && user.getRealJid() != null
 976                                    && conversation.getMucOptions().isPrivateAndNonAnonymous()
 977                                    && (contact == null || !contact.mutualPresenceSubscription())
 978                                    && account.getAxolotlService().hasEmptyDeviceList(user.getRealJid())) {
 979                                account.getAxolotlService().fetchDeviceIds(user.getRealJid());
 980                            }
 981                        }
 982                    }
 983                }
 984            }
 985            if (!isTypeGroupChat) {
 986                for (Element child : packet.getChildren()) {
 987                    if (Namespace.JINGLE_MESSAGE.equals(child.getNamespace()) && JINGLE_MESSAGE_ELEMENT_NAMES.contains(child.getName())) {
 988                        final String action = child.getName();
 989                        final String sessionId = child.getAttribute("id");
 990                        if (sessionId == null) {
 991                            break;
 992                        }
 993                        if (query == null) {
 994                            if (serverMsgId == null) {
 995                                serverMsgId = extractStanzaId(account, packet);
 996                            }
 997                            mXmppConnectionService.getJingleConnectionManager().deliverMessage(account, packet.getTo(), packet.getFrom(), child, remoteMsgId, serverMsgId, timestamp);
 998                            if (!account.getJid().asBareJid().equals(from.asBareJid()) && remoteMsgId != null) {
 999                                processMessageReceipts(account, packet, remoteMsgId, query);
1000                            }
1001                        } else if (query.isCatchup()) {
1002                            if ("propose".equals(action)) {
1003                                final Element description = child.findChild("description");
1004                                final String namespace = description == null ? null : description.getNamespace();
1005                                if (Namespace.JINGLE_APPS_RTP.equals(namespace)) {
1006                                    final Conversation c = mXmppConnectionService.findOrCreateConversation(account, counterpart.asBareJid(), false, false);
1007                                    final Message preExistingMessage = c.findRtpSession(sessionId, status);
1008                                    if (preExistingMessage != null) {
1009                                        preExistingMessage.setServerMsgId(serverMsgId);
1010                                        mXmppConnectionService.updateMessage(preExistingMessage);
1011                                        break;
1012                                    }
1013                                    final Message message = new Message(
1014                                            c,
1015                                            status,
1016                                            Message.TYPE_RTP_SESSION,
1017                                            sessionId
1018                                    );
1019                                    message.setServerMsgId(serverMsgId);
1020                                    message.setTime(timestamp);
1021                                    message.setBody(new RtpSessionStatus(false, 0).toString());
1022                                    c.add(message);
1023                                    mXmppConnectionService.databaseBackend.createMessage(message);
1024                                }
1025                            } else if ("proceed".equals(action)) {
1026                                //status needs to be flipped to find the original propose
1027                                final Conversation c = mXmppConnectionService.findOrCreateConversation(account, counterpart.asBareJid(), false, false);
1028                                final int s = packet.fromAccount(account) ? Message.STATUS_RECEIVED : Message.STATUS_SEND;
1029                                final Message message = c.findRtpSession(sessionId, s);
1030                                if (message != null) {
1031                                    message.setBody(new RtpSessionStatus(true, 0).toString());
1032                                    if (serverMsgId != null) {
1033                                        message.setServerMsgId(serverMsgId);
1034                                    }
1035                                    message.setTime(timestamp);
1036                                    mXmppConnectionService.updateMessage(message, true);
1037                                } else {
1038                                    Log.d(Config.LOGTAG, "unable to find original rtp session message for received propose");
1039                                }
1040
1041                            }
1042                        } else {
1043                            //MAM reloads (non catchups
1044                            if ("propose".equals(action)) {
1045                                final Element description = child.findChild("description");
1046                                final String namespace = description == null ? null : description.getNamespace();
1047                                if (Namespace.JINGLE_APPS_RTP.equals(namespace)) {
1048                                    final Conversation c = mXmppConnectionService.findOrCreateConversation(account, counterpart.asBareJid(), false, false);
1049                                    final Message preExistingMessage = c.findRtpSession(sessionId, status);
1050                                    if (preExistingMessage != null) {
1051                                        preExistingMessage.setServerMsgId(serverMsgId);
1052                                        mXmppConnectionService.updateMessage(preExistingMessage);
1053                                        break;
1054                                    }
1055                                    final Message message = new Message(
1056                                            c,
1057                                            status,
1058                                            Message.TYPE_RTP_SESSION,
1059                                            sessionId
1060                                    );
1061                                    message.setServerMsgId(serverMsgId);
1062                                    message.setTime(timestamp);
1063                                    message.setBody(new RtpSessionStatus(true, 0).toString());
1064                                    if (query.getPagingOrder() == MessageArchiveService.PagingOrder.REVERSE) {
1065                                        c.prepend(query.getActualInThisQuery(), message);
1066                                    } else {
1067                                        c.add(message);
1068                                    }
1069                                    query.incrementActualMessageCount();
1070                                    mXmppConnectionService.databaseBackend.createMessage(message);
1071                                }
1072                            }
1073                        }
1074                        break;
1075                    }
1076                }
1077            }
1078        }
1079
1080        Element received = packet.findChild("received", "urn:xmpp:chat-markers:0");
1081        if (received == null) {
1082            received = packet.findChild("received", "urn:xmpp:receipts");
1083        }
1084        if (received != null) {
1085            String id = received.getAttribute("id");
1086            if (packet.fromAccount(account)) {
1087                if (query != null && id != null && packet.getTo() != null) {
1088                    query.removePendingReceiptRequest(new ReceiptRequest(packet.getTo(), id));
1089                }
1090            } else if (id != null) {
1091                if (id.startsWith(JingleRtpConnection.JINGLE_MESSAGE_PROPOSE_ID_PREFIX)) {
1092                    final String sessionId = id.substring(JingleRtpConnection.JINGLE_MESSAGE_PROPOSE_ID_PREFIX.length());
1093                    mXmppConnectionService.getJingleConnectionManager()
1094                            .updateProposedSessionDiscovered(account, from, sessionId, JingleConnectionManager.DeviceDiscoveryState.DISCOVERED);
1095                } else {
1096                    mXmppConnectionService.markMessage(account, from.asBareJid(), id, Message.STATUS_SEND_RECEIVED);
1097                }
1098            }
1099        }
1100        Element displayed = packet.findChild("displayed", "urn:xmpp:chat-markers:0");
1101        if (displayed != null) {
1102            final String id = displayed.getAttribute("id");
1103            final Jid sender = InvalidJid.getNullForInvalid(displayed.getAttributeAsJid("sender"));
1104            if (packet.fromAccount(account) && !selfAddressed) {
1105                dismissNotification(account, counterpart, query, id);
1106                if (query == null) {
1107                    activateGracePeriod(account);
1108                }
1109            } else if (isTypeGroupChat) {
1110                final Conversation conversation = mXmppConnectionService.find(account, counterpart.asBareJid());
1111                final Message message;
1112                if (conversation != null && id != null) {
1113                    if (sender != null) {
1114                        message = conversation.findMessageWithRemoteId(id, sender);
1115                    } else {
1116                        message = conversation.findMessageWithServerMsgId(id);
1117                    }
1118                } else {
1119                    message = null;
1120                }
1121                if (message != null) {
1122                    final Jid fallback = conversation.getMucOptions().getTrueCounterpart(counterpart);
1123                    final Jid trueJid = getTrueCounterpart((query != null && query.safeToExtractTrueCounterpart()) ? mucUserElement : null, fallback);
1124                    final boolean trueJidMatchesAccount = account.getJid().asBareJid().equals(trueJid == null ? null : trueJid.asBareJid());
1125                    if (trueJidMatchesAccount || conversation.getMucOptions().isSelf(counterpart)) {
1126                        if (!message.isRead() && (query == null || query.isCatchup())) { //checking if message is unread fixes race conditions with reflections
1127                            mXmppConnectionService.markRead(conversation);
1128                        }
1129                    } else if (!counterpart.isBareJid() && trueJid != null) {
1130                        final ReadByMarker readByMarker = ReadByMarker.from(counterpart, trueJid);
1131                        if (message.addReadByMarker(readByMarker)) {
1132                            mXmppConnectionService.updateMessage(message, false);
1133                        }
1134                    }
1135                }
1136            } else {
1137                final Message displayedMessage = mXmppConnectionService.markMessage(account, from.asBareJid(), id, Message.STATUS_SEND_DISPLAYED);
1138                Message message = displayedMessage == null ? null : displayedMessage.prev();
1139                while (message != null
1140                        && message.getStatus() == Message.STATUS_SEND_RECEIVED
1141                        && message.getTimeSent() < displayedMessage.getTimeSent()) {
1142                    mXmppConnectionService.markMessage(message, Message.STATUS_SEND_DISPLAYED);
1143                    message = message.prev();
1144                }
1145                if (displayedMessage != null && selfAddressed) {
1146                    dismissNotification(account, counterpart, query, id);
1147                }
1148            }
1149        }
1150
1151        final Element event = original.findChild("event", "http://jabber.org/protocol/pubsub#event");
1152        if (event != null && InvalidJid.hasValidFrom(original) && original.getFrom().isBareJid()) {
1153            if (event.hasChild("items")) {
1154                parseEvent(event, original.getFrom(), account);
1155            } else if (event.hasChild("delete")) {
1156                parseDeleteEvent(event, original.getFrom(), account);
1157            } else if (event.hasChild("purge")) {
1158                parsePurgeEvent(event, original.getFrom(), account);
1159            }
1160        }
1161
1162        final String nick = packet.findChildContent("nick", Namespace.NICK);
1163        if (nick != null && InvalidJid.hasValidFrom(original)) {
1164            if (mXmppConnectionService.isMuc(account, from)) {
1165                return;
1166            }
1167            final Contact contact = account.getRoster().getContact(from);
1168            if (contact.setPresenceName(nick)) {
1169                mXmppConnectionService.syncRoster(account);
1170                mXmppConnectionService.getAvatarService().clear(contact);
1171            }
1172        }
1173    }
1174
1175    private void dismissNotification(Account account, Jid counterpart, MessageArchiveService.Query query, final String id) {
1176        final Conversation conversation = mXmppConnectionService.find(account, counterpart.asBareJid());
1177        if (conversation != null && (query == null || query.isCatchup())) {
1178            final String displayableId = conversation.findMostRecentRemoteDisplayableId();
1179            if (displayableId != null && displayableId.equals(id)) {
1180                mXmppConnectionService.markRead(conversation);
1181            } else {
1182                Log.w(Config.LOGTAG, account.getJid().asBareJid() + ": received dismissing display marker that did not match our last id in that conversation");
1183            }
1184        }
1185    }
1186
1187    private void processMessageReceipts(final Account account, final MessagePacket packet, final String remoteMsgId, MessageArchiveService.Query query) {
1188        final boolean markable = packet.hasChild("markable", "urn:xmpp:chat-markers:0");
1189        final boolean request = packet.hasChild("request", "urn:xmpp:receipts");
1190        if (query == null) {
1191            final ArrayList<String> receiptsNamespaces = new ArrayList<>();
1192            if (markable) {
1193                receiptsNamespaces.add("urn:xmpp:chat-markers:0");
1194            }
1195            if (request) {
1196                receiptsNamespaces.add("urn:xmpp:receipts");
1197            }
1198            if (receiptsNamespaces.size() > 0) {
1199                final MessagePacket receipt = mXmppConnectionService.getMessageGenerator().received(account,
1200                        packet.getFrom(),
1201                        remoteMsgId,
1202                        receiptsNamespaces,
1203                        packet.getType());
1204                mXmppConnectionService.sendMessagePacket(account, receipt);
1205            }
1206        } else if (query.isCatchup()) {
1207            if (request) {
1208                query.addPendingReceiptRequest(new ReceiptRequest(packet.getFrom(), remoteMsgId));
1209            }
1210        }
1211    }
1212
1213    private void activateGracePeriod(Account account) {
1214        long duration = mXmppConnectionService.getLongPreference("grace_period_length", R.integer.grace_period) * 1000;
1215        Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": activating grace period till " + TIME_FORMAT.format(new Date(System.currentTimeMillis() + duration)));
1216        account.activateGracePeriod(duration);
1217    }
1218
1219    private class Invite {
1220        final Jid jid;
1221        final String password;
1222        final boolean direct;
1223        final Jid inviter;
1224
1225        Invite(Jid jid, String password, boolean direct, Jid inviter) {
1226            this.jid = jid;
1227            this.password = password;
1228            this.direct = direct;
1229            this.inviter = inviter;
1230        }
1231
1232        public boolean execute(Account account) {
1233            if (jid != null) {
1234                Conversation conversation = mXmppConnectionService.findOrCreateConversation(account, jid, true, false);
1235                if (conversation.getMucOptions().online()) {
1236                    Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": received invite to " + jid + " but muc is considered to be online");
1237                    mXmppConnectionService.mucSelfPingAndRejoin(conversation);
1238                } else {
1239                    conversation.getMucOptions().setPassword(password);
1240                    mXmppConnectionService.databaseBackend.updateConversation(conversation);
1241                    final Contact contact = inviter != null ? account.getRoster().getContactFromContactList(inviter) : null;
1242                    mXmppConnectionService.joinMuc(conversation, contact != null && contact.mutualPresenceSubscription());
1243                    mXmppConnectionService.updateConversationUi();
1244                }
1245                return true;
1246            }
1247            return false;
1248        }
1249    }
1250}