diff --git a/libtextsecure/errors.js b/libtextsecure/errors.js index 0d5810f70..aa17a9710 100644 --- a/libtextsecure/errors.js +++ b/libtextsecure/errors.js @@ -47,18 +47,6 @@ } inherit(ReplayableError, IncomingIdentityKeyError); - function OutgoingIdentityKeyError(number, message, timestamp, identityKey) { - // eslint-disable-next-line prefer-destructuring - this.number = number.split('.')[0]; - this.identityKey = identityKey; - - ReplayableError.call(this, { - name: 'OutgoingIdentityKeyError', - message: `The identity of ${this.number} has changed.`, - }); - } - inherit(ReplayableError, OutgoingIdentityKeyError); - function SendMessageNetworkError(number, jsonData, httpError) { this.number = number; this.code = httpError.code; @@ -207,7 +195,6 @@ window.textsecure.SendMessageNetworkError = SendMessageNetworkError; window.textsecure.IncomingIdentityKeyError = IncomingIdentityKeyError; - window.textsecure.OutgoingIdentityKeyError = OutgoingIdentityKeyError; window.textsecure.ReplayableError = ReplayableError; window.textsecure.MessageError = MessageError; window.textsecure.EmptySwarmError = EmptySwarmError; diff --git a/libtextsecure/index.d.ts b/libtextsecure/index.d.ts index ec8452f1f..894521dc2 100644 --- a/libtextsecure/index.d.ts +++ b/libtextsecure/index.d.ts @@ -6,7 +6,6 @@ export interface LibTextsecure { storage: any; SendMessageNetworkError: any; IncomingIdentityKeyError: any; - OutgoingIdentityKeyError: any; ReplayableError: any; MessageError: any; EmptySwarmError: any; diff --git a/ts/models/message.ts b/ts/models/message.ts index dc5461c5b..cf34456e6 100644 --- a/ts/models/message.ts +++ b/ts/models/message.ts @@ -12,7 +12,7 @@ import { OpenGroupMessage, } from '../../ts/session/messages/outgoing'; import { ClosedGroupChatMessage } from '../../ts/session/messages/outgoing/content/data/group/ClosedGroupChatMessage'; -import { EncryptionType, PubKey } from '../../ts/session/types'; +import { EncryptionType, PubKey, RawMessage } from '../../ts/session/types'; import { ToastUtils, UserUtils } from '../../ts/session/utils'; import { fillMessageAttributesWithDefaults, @@ -665,7 +665,6 @@ export class MessageModel extends Backbone.Model { public async getPropsForMessageDetail() { const newIdentity = window.i18n('newIdentity'); - const OUTGOING_KEY_ERROR = 'OutgoingIdentityKeyError'; // We include numbers we didn't successfully send to so we can display errors. // Older messages don't have the recipients included on the message, so we fall @@ -681,11 +680,6 @@ export class MessageModel extends Backbone.Model { // This will make the error message for outgoing key errors a bit nicer const allErrors = (this.get('errors') || []).map((error: any) => { - if (error.name === OUTGOING_KEY_ERROR) { - // eslint-disable-next-line no-param-reassign - error.message = newIdentity; - } - return error; }); @@ -696,9 +690,7 @@ export class MessageModel extends Backbone.Model { const finalContacts = await Promise.all( (phoneNumbers || []).map(async id => { const errorsForContact = errorsGroupedById[id]; - const isOutgoingKeyError = Boolean( - _.find(errorsForContact, error => error.name === OUTGOING_KEY_ERROR) - ); + const isOutgoingKeyError = false; const contact = this.findAndFormatContact(id); return { @@ -940,140 +932,12 @@ export class MessageModel extends Backbone.Model { this.get('errors'), e => e.number === number && - (e.name === 'MessageError' || - e.name === 'SendMessageNetworkError' || - e.name === 'OutgoingIdentityKeyError') + (e.name === 'MessageError' || e.name === 'SendMessageNetworkError') ); this.set({ errors: errors[1] }); return errors[0][0]; } - /** - * This function is called by inbox_view.js when a message was successfully sent for one device. - * So it might be called several times for the same message - */ - public async handleMessageSentSuccess( - sentMessage: any, - wrappedEnvelope: any - ) { - let sentTo = this.get('sent_to') || []; - - let isOurDevice = false; - if (sentMessage.device) { - isOurDevice = UserUtils.isUsFromCache(sentMessage.device); - } - // FIXME this is not correct and will cause issues with syncing - // At this point the only way to check for medium - // group is by comparing the encryption type - const isClosedGroupMessage = - sentMessage.encryption === EncryptionType.ClosedGroup; - - const isOpenGroupMessage = - !!sentMessage.group && sentMessage.group instanceof Types.OpenGroup; - - // We trigger a sync message only when the message is not to one of our devices, AND - // the message is not for an open group (there is no sync for opengroups, each device pulls all messages), AND - // if we did not sync or trigger a sync message for this specific message already - const shouldTriggerSyncMessage = - !isOurDevice && - !isClosedGroupMessage && - !this.get('synced') && - !this.get('sentSync'); - - // A message is synced if we triggered a sync message (sentSync) - // and the current message was sent to our device (so a sync message) - const shouldMarkMessageAsSynced = isOurDevice && this.get('sentSync'); - - const isSessionOrClosedMessage = !isOpenGroupMessage; - - if (isSessionOrClosedMessage) { - const contentDecoded = SignalService.Content.decode( - sentMessage.plainTextBuffer - ); - const { dataMessage } = contentDecoded; - - /** - * We should hit the notify endpoint for push notification only if: - * • It's a one-to-one chat or a closed group - * • The message has either text or attachments - */ - const hasBodyOrAttachments = Boolean( - dataMessage && - (dataMessage.body || - (dataMessage.attachments && dataMessage.attachments.length)) - ); - const shouldNotifyPushServer = - hasBodyOrAttachments && isSessionOrClosedMessage; - - if (shouldNotifyPushServer) { - // notify the push notification server if needed - if (!wrappedEnvelope) { - window.log.warn('Should send PN notify but no wrapped envelope set.'); - } else { - if (!window.LokiPushNotificationServer) { - window.LokiPushNotificationServer = new window.LokiPushNotificationServerApi(); - } - - window.LokiPushNotificationServer.notify( - wrappedEnvelope, - sentMessage.device - ); - } - } - - // Handle the sync logic here - if (shouldTriggerSyncMessage) { - if (dataMessage) { - await this.sendSyncMessage( - dataMessage as SignalService.DataMessage, - sentMessage.timestamp - ); - } - } else if (shouldMarkMessageAsSynced) { - this.set({ synced: true }); - } - - sentTo = _.union(sentTo, [sentMessage.device]); - } - - this.set({ - sent_to: sentTo, - sent: true, - expirationStartTimestamp: Date.now(), - sent_at: sentMessage.timestamp, - }); - - await this.commit(); - - this.getConversation()?.updateLastMessage(); - } - - public async handleMessageSentFailure(sentMessage: any, error: any) { - if (error instanceof Error) { - await this.saveErrors(error); - if (error.name === 'OutgoingIdentityKeyError') { - const c = ConversationController.getInstance().get(sentMessage.device); - await c.getProfiles(); - } - } - let isOurDevice = false; - if (sentMessage.device) { - isOurDevice = UserUtils.isUsFromCache(sentMessage.device); - } - - const expirationStartTimestamp = Date.now(); - if (isOurDevice && !this.get('sync')) { - this.set({ sentSync: false }); - } - this.set({ - sent: true, - expirationStartTimestamp, - }); - await this.commit(); - - this.getConversation()?.updateLastMessage(); - } - public getConversation(): ConversationModel | undefined { // This needs to be an unsafe call, because this method is called during // initial module setup. We may be in the middle of the initial fetch to diff --git a/ts/session/sending/MessageQueue.ts b/ts/session/sending/MessageQueue.ts index f742678d8..0d4914083 100644 --- a/ts/session/sending/MessageQueue.ts +++ b/ts/session/sending/MessageQueue.ts @@ -79,7 +79,6 @@ export class MessageQueue { if (result.serverId < 0) { void MessageSentHandler.handleMessageSentFailure(message, error); } else { - void MessageSentHandler.handleMessageSentSuccess(message); void MessageSentHandler.handlePublicMessageSentSuccess(message, result); } } catch (e) { @@ -145,7 +144,7 @@ export class MessageQueue { const job = async () => { try { const wrappedEnvelope = await MessageSender.send(message); - void MessageSentHandler.handleMessageSentSuccess( + await MessageSentHandler.handleMessageSentSuccess( message, wrappedEnvelope ); diff --git a/ts/session/sending/MessageSentHandler.ts b/ts/session/sending/MessageSentHandler.ts index 4c7aeb6e2..9e3b8ae8a 100644 --- a/ts/session/sending/MessageSentHandler.ts +++ b/ts/session/sending/MessageSentHandler.ts @@ -1,7 +1,11 @@ +import _ from 'lodash'; import { getMessageById } from '../../data/data'; +import { SignalService } from '../../protobuf'; +import { ConversationController } from '../conversations'; import { MessageController } from '../messages'; import { OpenGroupMessage } from '../messages/outgoing'; -import { RawMessage } from '../types'; +import { EncryptionType, RawMessage } from '../types'; +import { UserUtils } from '../utils'; // tslint:disable-next-line no-unnecessary-class export class MessageSentHandler { @@ -25,15 +29,21 @@ export class MessageSentHandler { serverTimestamp, serverId, isPublic: true, + sent: true, + sent_at: sentMessage.timestamp, + sync: true, + synced: true, + sentSync: true, }); await foundMessage.commit(); + foundMessage.getConversation()?.updateLastMessage(); } catch (e) { window.log.error('Error setting public on message'); } } public static async handleMessageSentSuccess( - sentMessage: RawMessage | OpenGroupMessage, + sentMessage: RawMessage, wrappedEnvelope?: Uint8Array ) { // The wrappedEnvelope will be set only if the message is not one of OpenGroupMessage type. @@ -44,7 +54,88 @@ export class MessageSentHandler { return; } - void fetchedMessage.handleMessageSentSuccess(sentMessage, wrappedEnvelope); + let sentTo = fetchedMessage.get('sent_to') || []; + + let isOurDevice = false; + if (sentMessage.device) { + isOurDevice = UserUtils.isUsFromCache(sentMessage.device); + } + // FIXME this is not correct and will cause issues with syncing + // At this point the only way to check for medium + // group is by comparing the encryption type + const isClosedGroupMessage = + sentMessage.encryption === EncryptionType.ClosedGroup; + + // We trigger a sync message only when the message is not to one of our devices, AND + // the message is not for an open group (there is no sync for opengroups, each device pulls all messages), AND + // if we did not sync or trigger a sync message for this specific message already + const shouldTriggerSyncMessage = + !isOurDevice && + !isClosedGroupMessage && + !fetchedMessage.get('synced') && + !fetchedMessage.get('sentSync'); + + // A message is synced if we triggered a sync message (sentSync) + // and the current message was sent to our device (so a sync message) + const shouldMarkMessageAsSynced = + isOurDevice && fetchedMessage.get('sentSync'); + + const contentDecoded = SignalService.Content.decode( + sentMessage.plainTextBuffer + ); + const { dataMessage } = contentDecoded; + + /** + * We should hit the notify endpoint for push notification only if: + * • It's a one-to-one chat or a closed group + * • The message has either text or attachments + */ + const hasBodyOrAttachments = Boolean( + dataMessage && + (dataMessage.body || + (dataMessage.attachments && dataMessage.attachments.length)) + ); + const shouldNotifyPushServer = hasBodyOrAttachments && !isOurDevice; + + if (shouldNotifyPushServer) { + // notify the push notification server if needed + if (!wrappedEnvelope) { + window.log.warn('Should send PN notify but no wrapped envelope set.'); + } else { + if (!window.LokiPushNotificationServer) { + window.LokiPushNotificationServer = new window.LokiPushNotificationServerApi(); + } + + window.LokiPushNotificationServer.notify( + wrappedEnvelope, + sentMessage.device + ); + } + } + + // Handle the sync logic here + if (shouldTriggerSyncMessage) { + if (dataMessage) { + await fetchedMessage.sendSyncMessage( + dataMessage as SignalService.DataMessage, + sentMessage.timestamp + ); + } + } else if (shouldMarkMessageAsSynced) { + fetchedMessage.set({ synced: true }); + } + + sentTo = _.union(sentTo, [sentMessage.device]); + + fetchedMessage.set({ + sent_to: sentTo, + sent: true, + expirationStartTimestamp: Date.now(), + sent_at: sentMessage.timestamp, + }); + + await fetchedMessage.commit(); + fetchedMessage.getConversation()?.updateLastMessage(); } public static async handleMessageSentFailure( @@ -58,7 +149,32 @@ export class MessageSentHandler { return; } - await fetchedMessage.handleMessageSentFailure(sentMessage, error); + if (error instanceof Error) { + await fetchedMessage.saveErrors(error); + } + + if (!(sentMessage instanceof OpenGroupMessage)) { + const isOurDevice = UserUtils.isUsFromCache(sentMessage.device); + // if this message was for ourself, and it was not already synced, + // it means that we failed to sync it. + // so just remove the flag saying that we are currently sending the sync message + if (isOurDevice && !fetchedMessage.get('sync')) { + fetchedMessage.set({ sentSync: false }); + } + + fetchedMessage.set({ + expirationStartTimestamp: Date.now(), + }); + } + + // always mark the message as sent. + // the fact that we have errors on the sent is based on the saveErrors() + fetchedMessage.set({ + sent: true, + }); + + await fetchedMessage.commit(); + await fetchedMessage.getConversation()?.updateLastMessage(); } /** @@ -73,13 +189,14 @@ export class MessageSentHandler { private static async fetchHandleMessageSentData( m: RawMessage | OpenGroupMessage ) { - // if a message was sent and this message was created after the last app restart, + // if a message was sent and this message was sent after the last app restart, // this message is still in memory in the MessageController const msg = MessageController.getInstance().get(m.identifier); if (!msg || !msg.message) { // otherwise, look for it in the database // nobody is listening to this freshly fetched message .trigger calls + // so we can just update the fields on the database const dbMessage = await getMessageById(m.identifier); if (!dbMessage) {