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