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