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