Core Apps » ChatSecure:Android

				63B916E01B743198003B778F /* OTRStreamManagementYapStorage.h */,

				63B916E11B743198003B778F /* OTRStreamManagementYapStorage.m */,

				637DBB1A1B7D5A23003845B7 /* OTRXMPPMessageYapStorage.h */,

				637DBB1B1B7D5A23003845B7 /* OTRXMPPMessageYapStorage.m */,

				633105331A16D1A300C17BAE /* OTRvCardYapDatabaseStorage.h */,

				633105341A16D1A300C17BAE /* OTRvCardYapDatabaseStorage.m */,

				6331053D1A16D1A300C17BAE /* OTRYapDatabaseRosterStorage.h */,

				6331053E1A16D1A300C17BAE /* OTRYapDatabaseRosterStorage.m */,

				63BB66AD1BC5D2F40004A619 /* OTRXMPPRoomYapStorage.h */,

				63BB66AE1BC5D2F40004A619 /* OTRXMPPRoomYapStorage.m */,

    @objc public func extractStanzaId(account: OTRXMPPAccount) -> String? {

        let xmpp = OTRProtocolManager.shared.protocol(for: account) as? OTRXMPPManager,

        xmpp.xmppCapabilities.hasValidStanzaId(self) else {

//

//  OTRStreamManagementYapStorage.h

//  ChatSecure

//

//  Created by David Chiles on 11/19/14.

//  Copyright (c) 2014 Chris Ballinger. All rights reserved.

//

@import Foundation;

@import XMPPFramework;

@class YapDatabaseConnection;

NS_ASSUME_NONNULL_BEGIN

@interface OTRStreamManagementYapStorage : NSObject <XMPPStreamManagementStorage>

- (instancetype)initWithDatabaseConnection:(YapDatabaseConnection *)databaseConnection;

@property (nonatomic, strong, readonly) YapDatabaseConnection *databaseConnection;

@end

NS_ASSUME_NONNULL_END

//

//  OTRStreamManagementYapStorage.m

//  ChatSecure

//

//  Created by David Chiles on 11/19/14.

//  Copyright (c) 2014 Chris Ballinger. All rights reserved.

//

#import "OTRStreamManagementYapStorage.h"

@import XMPPFramework;

@import YapDatabase;

#import "OTRStreamManagementStorageObject.h"

@interface OTRStreamManagementYapStorage ()

@property (nonatomic, readonly) dispatch_queue_t parentQueue;

@end

@implementation OTRStreamManagementYapStorage

- (instancetype)initWithDatabaseConnection:(YapDatabaseConnection *)databaseConnection

{

    if (self = [super init]) {

        _databaseConnection = databaseConnection;

    }

    return self;

}

- (NSString *)accountUniqueIdForStream:(XMPPStream *)stream

{

    return stream.tag;

}

 #pragma - mark XMPPStramManagementDelegate Methods

//

//

// -- PRIVATE METHODS --

//

// These methods are designed to be used ONLY by the XMPPStreamManagement class.

//

//

/**

 * Configures the storage class, passing it's parent and the parent's dispatch queue.

 *

 * This method is called by the init methods of the XMPPStreamManagement class.

 * This method is designed to inform the storage class of it's parent

 * and of the dispatch queue the parent will be operating on.

 *

 * A storage class may choose to operate on the same queue as it's parent,

 * as the majority of the time it will be getting called by the parent.

 * If both are operating on the same queue, the combination may run faster.

 *

 * Some storage classes support multiple xmppStreams,

 * and may choose to operate on their own internal queue.

 *

 * This method should return YES if it was configured properly.

 * It should return NO only if configuration failed.

 * For example, a storage class designed to be used only with a single xmppStream is being added to a second stream.

 **/

- (BOOL)configureWithParent:(XMPPStreamManagement *)parent queue:(dispatch_queue_t)queue

{

    _parentQueue = queue;

    return YES;

}

- (OTRStreamManagementStorageObject *)fetchOrCreateStorageObjectWithStream:(XMPPStream *)stream transaction:(YapDatabaseReadTransaction *)transaction

{

    NSString *accountUniqueId = [self accountUniqueIdForStream:stream];

    OTRStreamManagementStorageObject *storageObject = [OTRStreamManagementStorageObject fetchObjectWithUniqueID:accountUniqueId transaction:transaction];

    if (!storageObject) {

        storageObject = [[OTRStreamManagementStorageObject alloc] initWithUniqueId:accountUniqueId];

    } else {

        storageObject = [storageObject copy];

    }

    return storageObject;

}

/**

 * Invoked after we receive <enabled/> from the server.

 *

 * @param resumptionId

 *   The ID required to resume the session, given to us by the server.

 *

 * @param timeout

 *   The timeout in seconds.

 *   After a disconnect, the server will maintain our state for this long.

 *   If we attempt to resume the session after this timeout it likely won't work.

 *

 * @param lastDisconnect

 *   Used to reset the lastDisconnect value.

 *   This value is often updated during the session, to ensure it closely resemble the date the server will use.

 *   That is, if the client application is killed (or crashes) we want a relatively accurate lastDisconnect date.

 *

 * @param stream

 *   The associated xmppStream (standard parameter for storage classes)

 *

 * This method should also nil out the following values (if needed) associated with the account:

 * - lastHandledByClient

 * - lastHandledByServer

 * - pendingOutgoingStanzas

 **/

- (void)setResumptionId:(NSString *)resumptionId

                timeout:(uint32_t)timeout

         lastDisconnect:(NSDate *)date

              forStream:(XMPPStream *)stream

{

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        OTRStreamManagementStorageObject *storageObject = [self fetchOrCreateStorageObjectWithStream:stream transaction:transaction];

        storageObject.timeout = timeout;

        storageObject.lastDisconnectDate = date;

        storageObject.resumptionId = resumptionId;

        [storageObject saveWithTransaction:transaction];

    }];

}

/**

 * This method is invoked ** often ** during stream operation.

 * It is not invoked when the xmppStream is disconnected.

 *

 * Important: See the note below: "Optimizing storage demands during active stream usage"

 *

 * @param date

 *   Updates the previous lastDisconnect value.

 *

 * @param lastHandledByClient

 *   The most recent 'h' value we can safely send to the server.

 *

 * @param stream

 *   The associated xmppStream (standard parameter for storage classes)

 **/

- (void)setLastDisconnect:(NSDate *)date

      lastHandledByClient:(uint32_t)lastHandledByClient

                forStream:(XMPPStream *)stream

{

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        OTRStreamManagementStorageObject *storageObject = [self fetchOrCreateStorageObjectWithStream:stream transaction:transaction];

        storageObject.lastDisconnectDate = date;

        storageObject.lastHandledByClient = lastHandledByClient;

        [storageObject saveWithTransaction:transaction];

    }];

}

/**

 * This method is invoked ** often ** during stream operation.

 * It is not invoked when the xmppStream is disconnected.

 *

 * Important: See the note below: "Optimizing storage demands during active stream usage"

 *

 * @param date

 *   Updates the previous lastDisconnect value.

 *

 * @param lastHandledByServer

 *   The most recent 'h' value we've received from the server.

 *

 * @param pendingOutgoingStanzas

 *   An array of XMPPStreamManagementOutgoingStanza objects.

 *   The storage layer is in charge of properly persisting this array, including:

 *   - the array count

 *   - the stanzaId of each element, including those that are nil

 *

 * @param stream

 *   The associated xmppStream (standard parameter for storage classes)

 **/

- (void)setLastDisconnect:(NSDate *)date

      lastHandledByServer:(uint32_t)lastHandledByServer

   pendingOutgoingStanzas:(NSArray *)pendingOutgoingStanzas

                forStream:(XMPPStream *)stream

{

    //TODO: only do saves every so often

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        OTRStreamManagementStorageObject *storageObject = [self fetchOrCreateStorageObjectWithStream:stream transaction:transaction];

        storageObject.lastDisconnectDate = date;

        storageObject.lastHandledByServer = lastHandledByServer;

        storageObject.pendingOutgoingStanzasArray = pendingOutgoingStanzas;

        [storageObject saveWithTransaction:transaction];

    }];

}

/// ***** Optimizing storage demands during active stream usage *****

///

/// There are 2 methods that are invoked frequently during stream activity:

///

/// - setLastDisconnect:lastHandledByClient:forStream:

/// - setLastDisconnect:lastHandledByServer:pendingOutgoingStanzas:forStream:

///

/// They are invoked any time the 'h' values change, or whenver the pendingStanzaIds change.

/// In other words, they are invoked continually as stanzas get sent and received.

/// And it is the job of the storage layer to decide how to handle the traffic.

/// There are a few things to consider here:

///

/// - How much chatter does the xmppStream do?

/// - How fast is the storage layer?

/// - How does the overhead on the storage layer affect the rest of the app?

///

/// If your xmppStream isn't very chatty, and you've got a fast concurrent database,

/// then you may be able to simply pipe all these method calls to the database without thinking.

/// However, if your xmppStream is always constantly sending/receiving presence stanzas, and pinging the server,

/// then you might consider a bit of optimzation here. Below is a simple recommendation for how to accomplish this.

///

/// You could choose to queue the changes from these method calls, and dump them to the database after a timeout.

/// Thus you'll be able to consolidate a large traffic surge into a small handful of database operations.

///

/// Also, you could expose a 'flush' operation on the storage layer.

/// And invoke the flush operation when the app is backgrounded, or about to quit.

/**

 * This method is invoked immediately after an accidental disconnect.

 * And may be invoked post-disconnect if the state changes, such as for the following edge cases:

 *

 * - due to continued processing of stanzas received pre-disconnect,

 *   that are just now being marked as handled by the delegate(s)

 * - due to a delayed response from the delegate(s),

 *   such that we didn't receive the stanzaId for an outgoing stanza until after the disconnect occurred.

 *

 * This method is not invoked if stream management is started on a connected xmppStream.

 *

 * @param date

 *   This value will be the actual disconnect date.

 *

 * @param lastHandledByClient

 *   The most recent 'h' value we can safely send to the server.

 *

 * @param lastHandledByServer

 *   The most recent 'h' value we've received from the server.

 *

 * @param pendingOutgoingStanzas

 *   An array of XMPPStreamManagementOutgoingStanza objects.

 *   The storage layer is in charge of properly persisting this array, including:

 *   - the array count

 *   - the stanzaId of each element, including those that are nil

 *

 * @param stream

 *   The associated xmppStream (standard parameter for storage classes)

 **/

- (void)setLastDisconnect:(NSDate *)date

      lastHandledByClient:(uint32_t)lastHandledByClient

      lastHandledByServer:(uint32_t)lastHandledByServer

   pendingOutgoingStanzas:(NSArray *)pendingOutgoingStanzas

                forStream:(XMPPStream *)stream

{

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        OTRStreamManagementStorageObject *storageObject = [self fetchOrCreateStorageObjectWithStream:stream transaction:transaction];

        storageObject.lastDisconnectDate = date;

        storageObject.lastHandledByClient = lastHandledByClient;

        storageObject.lastHandledByServer = lastHandledByServer;

        storageObject.pendingOutgoingStanzasArray = pendingOutgoingStanzas;

        [storageObject saveWithTransaction:transaction];

    }];

}

/**

 * Invoked when the extension needs values from a previous session.

 * This method is used to get values needed in order to determine if it can resume a previous stream.

 **/

- (void)getResumptionId:(NSString * __autoreleasing *)resumptionIdPtr

                timeout:(uint32_t *)timeoutPtr

         lastDisconnect:(NSDate * __autoreleasing *)lastDisconnectPtr

              forStream:(XMPPStream *)stream

{

    [self.databaseConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {

        OTRStreamManagementStorageObject *storageObject = [OTRStreamManagementStorageObject fetchObjectWithUniqueID:[self accountUniqueIdForStream:stream] transaction:transaction];

        if (storageObject) {

            *resumptionIdPtr = storageObject.resumptionId;

            *timeoutPtr = storageObject.timeout;

            *lastDisconnectPtr = storageObject.lastDisconnectDate;

        }

    }];

}

/**

 * Invoked when the extension needs values from a previous session.

 * This method is used to get values needed in order to resume a previous stream.

 **/

- (void)getLastHandledByClient:(uint32_t * _Nullable)lastHandledByClientPtr

           lastHandledByServer:(uint32_t * _Nullable)lastHandledByServerPtr

        pendingOutgoingStanzas:(NSArray<XMPPStreamManagementOutgoingStanza*> * _Nullable __autoreleasing * _Nullable)pendingOutgoingStanzasPtr

                     forStream:(XMPPStream *)stream;

{

    [self.databaseConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {

        OTRStreamManagementStorageObject *storageObject = [OTRStreamManagementStorageObject fetchObjectWithUniqueID:[self accountUniqueIdForStream:stream] transaction:transaction];

        if (storageObject) {

            *lastHandledByClientPtr = storageObject.lastHandledByClient;

            *lastHandledByServerPtr = storageObject.lastHandledByServer;

            *pendingOutgoingStanzasPtr = storageObject.pendingOutgoingStanzasArray;

        }

    }];

}

/**

 * Instructs the storage layer to remove all values stored for the given stream.

 * This occurs after the extension detects a "cleanly closed stream",

 * in which case the stream cannot be resumed next time.

 **/

- (void)removeAllForStream:(XMPPStream *)stream

{

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        [transaction removeObjectForKey:[self accountUniqueIdForStream:stream]

                           inCollection:[OTRStreamManagementStorageObject collection]];

    }];

}

@end

@property (nonatomic, strong, readonly) XMPPMessageArchiveManagement *xmppMAM;

    _messageStorage = [[OTRXMPPMessageYapStorage alloc] initWithDatabaseConnection:self.databaseConnection];

    // Message Carbons

    _messageCarbons = [[XMPPMessageCarbons alloc] init];

    [self.messageCarbons addDelegate:self.messageStorage delegateQueue:self.messageStorage.moduleDelegateQueue];

    [self.messageCarbons activate:self.xmppStream];

    // Message archiving

    _xmppMAM = [[XMPPMessageArchiveManagement alloc] init];

    [self.xmppMAM addDelegate:self.messageStorage delegateQueue:self.messageStorage.moduleDelegateQueue];

    [self.xmppMAM activate:self.xmppStream];

    _roomManager = [[OTRXMPPRoomManager alloc] init];

    self.roomManager.databaseConnection = [OTRDatabaseManager sharedInstance].readWriteDatabaseConnection;

    [_messageCarbons        deactivate];

    [self.xmppMAM retrieveMessageArchiveWithFields:nil withResultSet:nil];

@property (nonatomic, strong, readonly) XMPPMessageCarbons *messageCarbons;

@property (nonatomic, strong, readonly) OTRXMPPMessageYapStorage *messageStorage;

//

//  OTRXMPPMessageYapStroage.h

//  ChatSecure

//

//  Created by David Chiles on 8/13/15.

//  Copyright (c) 2015 Chris Ballinger. All rights reserved.

//

@import XMPPFramework;

@import YapDatabase;

@class XMPPMessage;

NS_ASSUME_NONNULL_BEGIN

@interface OTRXMPPMessageYapStorage : XMPPModule <XMPPMessageCarbonsDelegate>

@property (nonatomic, strong, readonly) YapDatabaseConnection *databaseConnection;

@property (nonatomic, readonly) dispatch_queue_t moduleDelegateQueue;

/** This connection is only used for readWrites */

- (instancetype)initWithDatabaseConnection:(YapDatabaseConnection *)databaseConnection;

@end

NS_ASSUME_NONNULL_END

//

//  OTRXMPPMessageYapStroage.m

//  ChatSecure

//

//  Created by David Chiles on 8/13/15.

//  Copyright (c) 2015 Chris Ballinger. All rights reserved.

//

#import "OTRXMPPMessageYapStorage.h"

@import XMPPFramework;

#import "OTRLog.h"

@import OTRKit;

#import "OTRXMPPBuddy.h"

#import "OTRIncomingMessage.h"

#import "OTROutgoingMessage.h"

#import "OTRAccount.h"

#import "OTRConstants.h"

#import <ChatSecureCore/ChatSecureCore-Swift.h>

#import "OTRThreadOwner.h"

#import "OTRBuddyCache.h"

#import "OTRXMPPError.h"

#import "OTRXMPPManager_Private.h"

@implementation OTRXMPPMessageYapStorage

- (instancetype)initWithDatabaseConnection:(YapDatabaseConnection *)connection

{

    if (self = [self init]) {

        _databaseConnection = connection;

        _moduleDelegateQueue = dispatch_queue_create("OTRXMPPMessageYapStroage-delegateQueue", 0);

    }

    return self;

}

- (OTRXMPPBuddy *)buddyForJID:(XMPPJID *)jid stream:(XMPPStream *)stream transaction:(YapDatabaseReadTransaction *)transaction

{

    NSParameterAssert(jid);

    NSParameterAssert(stream.tag);

    NSParameterAssert(transaction);

    if (!stream.tag || !jid || !transaction) { return nil; }

    return [OTRXMPPBuddy fetchBuddyWithJid:jid accountUniqueId:stream.tag transaction:transaction];

}

- (OTRBaseMessage *)baseMessageFromXMPPMessage:(XMPPMessage *)xmppMessage buddyId:(NSString *)buddyId class:(Class)class {

    NSString *body = [xmppMessage body];

    NSDate * date = [xmppMessage delayedDeliveryDate];

    OTRBaseMessage *message = [[class alloc] init];

    message.text = body;

    message.buddyUniqueId = buddyId;

    if (date) {

        message.date = date;

    }

    message.messageId = [xmppMessage elementID];

    return message;

}

- (OTROutgoingMessage *)outgoingMessageFromXMPPMessage:(XMPPMessage *)xmppMessage buddyId:(NSString *)buddyId {

    OTROutgoingMessage *outgoingMessage = (OTROutgoingMessage *)[self baseMessageFromXMPPMessage:xmppMessage buddyId:buddyId class:[OTROutgoingMessage class]];

    // Fill in current data so it looks like this 'outgoing' message was really sent (but of course this is a message we received through carbons).

    outgoingMessage.dateSent = [NSDate date];

    return outgoingMessage;

}

- (OTRIncomingMessage *)incomingMessageFromXMPPMessage:(XMPPMessage *)xmppMessage buddyId:(NSString *)buddyId

{

    return (OTRIncomingMessage *)[self baseMessageFromXMPPMessage:xmppMessage buddyId:buddyId class:[OTRIncomingMessage class]];

}

- (void)xmppStream:(XMPPStream *)stream didReceiveMessage:(XMPPMessage *)xmppMessage

{

    // We don't handle incoming group chat messages here

    // Check out OTRXMPPRoomYapStorage instead

    if ([[xmppMessage type] isEqualToString:@"groupchat"] ||

        [xmppMessage elementForName:@"x" xmlns:XMPPMUCUserNamespace] ||

        [xmppMessage elementForName:@"x" xmlns:@"jabber:x:conference"]) {

        return;

    }

    // We handle carbons elsewhere via XMPPMessageCarbonsDelegate

    // We handle MAM elsewhere as well

    if (xmppMessage.isMessageCarbon ||

        xmppMessage.mamResult) {

        return;

    }

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        if (![stream.tag isKindOfClass:[NSString class]]) {

            DDLogError(@"Error - No account tag on stream %@", stream);

            return;

        }

        NSString *accountId = stream.tag;

        NSString *username = [[xmppMessage from] bare];

        XMPPJID *fromJID = xmppMessage.from;

        if (!fromJID) {

            DDLogWarn(@"No from for message: %@", xmppMessage);

            return;

        }

        OTRXMPPAccount *account = [OTRXMPPAccount fetchObjectWithUniqueID:accountId transaction:transaction];

        if (!account) {

            DDLogWarn(@"No account for message: %@", xmppMessage);

            return;

        }

        OTRXMPPBuddy *messageBuddy = [self buddyForJID:fromJID stream:stream transaction:transaction];

        if (!messageBuddy) {

            // message from server

            DDLogWarn(@"No buddy for message: %@", xmppMessage);

            return;

        }

        [self handleChatState:xmppMessage fromJID:fromJID stream:stream transaction:transaction];

        [self handleDeliverResponse:xmppMessage transaction:transaction];

        // If we receive a message from an online buddy that counts as them interacting with us

        OTRThreadStatus status = [OTRBuddyCache.shared threadStatusForBuddy:messageBuddy];

        if (status != OTRThreadStatusOffline &&

            ![xmppMessage hasReceiptResponse] &&

            ![xmppMessage isErrorMessage]) {

            [OTRBuddyCache.shared setLastSeenDate:[NSDate date] forBuddy:messageBuddy];

        }

        // Check if this is a bounced outgoing message / error

        NSString *eid = [xmppMessage elementID];

        if (eid && [xmppMessage isErrorMessage]) {

            id<OTRMessageProtocol> existingMessage = [OTROutgoingMessage messageForMessageId:eid transaction:transaction];            

            if ([existingMessage isKindOfClass:[OTROutgoingMessage class]]) {

                OTROutgoingMessage *message = (OTROutgoingMessage*)existingMessage;

                message.error = [OTRXMPPError errorForXMLElement:xmppMessage];

                [message saveWithTransaction:transaction];

            } else if ([existingMessage isKindOfClass:[OTRIncomingMessage class]]) {

                NSString *errorText = [[xmppMessage elementForName:@"error"] elementForName:@"text"].stringValue;

                if ([errorText containsString:@"OTR Error"]) {

                    // automatically renegotiate a new session when there's an error

                    [[OTRProtocolManager sharedInstance].encryptionManager.otrKit initiateEncryptionWithUsername:username accountName:account.username protocol:account.protocolTypeString];

                }

            }

            return;

        }

        OTRIncomingMessage *message = [self incomingMessageFromXMPPMessage:xmppMessage buddyId:messageBuddy.uniqueId];

        NSString *activeThreadYapKey = [[OTRAppDelegate appDelegate] activeThreadYapKey];

        if([activeThreadYapKey isEqualToString:message.threadId]) {

            message.read = YES;

        }

        // Extract XEP-0359 stanza-id

        NSString *originId = xmppMessage.originId;

        NSString *stanzaId = [xmppMessage extractStanzaIdWithAccount:account];

        message.originId = originId;

        message.stanzaId = stanzaId;

        if ([self isDuplicateMessage:xmppMessage stanzaId:stanzaId buddyUniqueId:messageBuddy.uniqueId transaction:transaction]) {

            DDLogWarn(@"Duplicate message received: %@", xmppMessage);

            return;

        }

        if (message.text) {

            [[OTRProtocolManager sharedInstance].encryptionManager.otrKit decodeMessage:message.text username:messageBuddy.username accountName:account.username protocol:kOTRProtocolTypeXMPP tag:message];

        }

    }];

}

- (void)handleChatState:(XMPPMessage *)xmppMessage fromJID:(XMPPJID *)fromJID stream:(XMPPStream *)stream transaction:(YapDatabaseReadTransaction *)transaction

{

    // Saves aren't needed when setting chatState or status because OTRBuddyCache is used internally

    OTRXMPPBuddy *messageBuddy = [self buddyForJID:fromJID stream:stream transaction:transaction];

    if (!messageBuddy) { return; }

    OTRChatState chatState = OTRChatStateUnknown;

    if([xmppMessage hasChatState])

    {

        if([xmppMessage hasComposingChatState])

            chatState = OTRChatStateComposing;

        else if([xmppMessage hasPausedChatState])

            chatState = OTRChatStatePaused;

        else if([xmppMessage hasActiveChatState])

            chatState = OTRChatStateActive;

        else if([xmppMessage hasInactiveChatState])

            chatState = OTRChatStateInactive;

        else if([xmppMessage hasGoneChatState])

            chatState = OTRChatStateGone;

    }

    [OTRBuddyCache.shared setChatState:chatState forBuddy:messageBuddy];

}

- (void)handleDeliverResponse:(XMPPMessage *)xmppMessage transaction:(YapDatabaseReadWriteTransaction *)transaction

{

    if ([xmppMessage hasReceiptResponse] && ![xmppMessage isErrorMessage]) {

        [OTROutgoingMessage receivedDeliveryReceiptForMessageId:[xmppMessage receiptResponseID] transaction:transaction];

    }

}

/** It is a violation of the XMPP spec to discard messages with duplicate stanza elementIds. We must use XEP-0359 stanza-id only. */

- (BOOL)isDuplicateMessage:(XMPPMessage *)message stanzaId:(NSString*)stanzaId buddyUniqueId:(NSString *)buddyUniqueId transaction:(YapDatabaseReadWriteTransaction *)transaction

{

    __block BOOL result = NO;

    if (!stanzaId.length) {

        return NO;

    }

    [transaction enumerateMessagesWithElementId:nil originId:nil stanzaId:stanzaId block:^(id<OTRMessageProtocol> _Nonnull databaseMessage, BOOL * _Null_unspecified stop) {

        if ([[databaseMessage threadId] isEqualToString:buddyUniqueId]) {

            *stop = YES;

            result = YES;

        }

    }];

    return result;

}

/// Handles both Carbons and MAM

- (void)handleForwardedMessage:(XMPPMessage *)forwardedMessage delayedDeliveryDate:(nullable NSDate*)delayedDeliveryDate stream:(XMPPStream *)stream outgoing:(BOOL)isOutgoing

{

    if (!forwardedMessage.isMessageWithBody ||

        forwardedMessage.isErrorMessage ||

        [OTRKit stringStartsWithOTRPrefix:forwardedMessage.body]) {

        DDLogWarn(@"Discarding forwarded message: %@", forwardedMessage.prettyXMLString);

        return;

    }

    //Sent Message Carbons are sent by our account to another

    //So from is our JID and to is buddy

    BOOL incoming = !isOutgoing;

    XMPPJID *jid = nil;

    if (incoming) {

        jid = forwardedMessage.from;

    } else {

        jid = forwardedMessage.to;

    }

    if (!jid) { return; }

    NSString *accountId = stream.tag;

    if (!accountId.length) { return; }

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction * __nonnull transaction) {

        OTRXMPPAccount *account = [OTRXMPPAccount fetchObjectWithUniqueID:accountId transaction:transaction];

        OTRXMPPBuddy *buddy = [self buddyForJID:jid stream:stream transaction:transaction];

        if (!buddy || !account) {

            return;

        }

        // Extract XEP-0359 stanza-id

        NSString *originId = forwardedMessage.originId;

        NSString *stanzaId = [forwardedMessage extractStanzaIdWithAccount:account];

        if (incoming) {

            [self handleChatState:forwardedMessage fromJID:jid stream:stream transaction:transaction];

            [self handleDeliverResponse:forwardedMessage transaction:transaction];

        }

        if ([self isDuplicateMessage:forwardedMessage stanzaId:stanzaId buddyUniqueId:buddy.uniqueId transaction:transaction]) {

            DDLogWarn(@"Duplicate message received: %@", forwardedMessage);

            return;

        }

        OTRBaseMessage *message = nil;

        if (incoming) {

            OTRIncomingMessage *incomingMessage = [self incomingMessageFromXMPPMessage:forwardedMessage buddyId:buddy.uniqueId];

            NSString *activeThreadYapKey = [[OTRAppDelegate appDelegate] activeThreadYapKey];

            if([activeThreadYapKey isEqualToString:message.threadId]) {

                incomingMessage.read = YES;

            }

            message = incomingMessage;

        } else {

            message = [self outgoingMessageFromXMPPMessage:forwardedMessage buddyId:buddy.uniqueId];

        }

        if (delayedDeliveryDate) {

            message.date = delayedDeliveryDate;

        }

        message.originId = originId;

        message.stanzaId = stanzaId;

        [message saveWithTransaction:transaction];

    }];

}

#pragma mark - XMPPMessageCarbonsDelegate

- (void)xmppMessageCarbons:(XMPPMessageCarbons *)xmppMessageCarbons willReceiveMessage:(XMPPMessage *)message outgoing:(BOOL)isOutgoing { }

- (void)xmppMessageCarbons:(XMPPMessageCarbons *)xmppMessageCarbons didReceiveMessage:(XMPPMessage *)message outgoing:(BOOL)isOutgoing

{

    [self handleForwardedMessage:message delayedDeliveryDate:nil stream:xmppMessageCarbons.xmppStream outgoing:isOutgoing];

}

#pragma mark - XMPPMessageArchiveManagementDelegate

- (void)xmppMessageArchiveManagement:(XMPPMessageArchiveManagement *)xmppMessageArchiveManagement didFinishReceivingMessagesWithSet:(XMPPResultSet *)resultSet {

    DDLogVerbose(@"MAM didFinishReceivingMessagesWithSet: %@", resultSet.prettyXMLString);

}

- (void)xmppMessageArchiveManagement:(XMPPMessageArchiveManagement *)xmppMessageArchiveManagement didReceiveMAMMessage:(XMPPMessage *)message {

    DDLogVerbose(@"MAM didReceiveMAMMessage: %@", message.prettyXMLString);

    NSXMLElement *result = message.mamResult;

    XMPPMessage *forwardedMessage = result.forwardedMessage;

    if (!forwardedMessage) { return; }

    NSDate *delayedDeliveryDate = result.forwardedStanzaDelayedDeliveryDate;

    XMPPJID *fromJID = forwardedMessage.from;

    if (!fromJID) { return; }

    BOOL isOutgoing = [fromJID isEqualToJID:xmppMessageArchiveManagement.xmppStream.myJID options:XMPPJIDCompareBare];

    [self handleForwardedMessage:forwardedMessage delayedDeliveryDate:delayedDeliveryDate stream:xmppMessageArchiveManagement.xmppStream outgoing:isOutgoing];

}

- (void)xmppMessageArchiveManagement:(XMPPMessageArchiveManagement *)xmppMessageArchiveManagement didFailToReceiveMessages:(XMPPIQ *)error {

    DDLogError(@"MAM didFailToReceiveMessages: %@", error.prettyXMLString);

}

- (void)xmppMessageArchiveManagement:(XMPPMessageArchiveManagement *)xmppMessageArchiveManagement didReceiveFormFields:(XMPPIQ *)iq {

    DDLogVerbose(@"MAM didReceiveFormFields: %@", iq.prettyXMLString);

}

- (void)xmppMessageArchiveManagement:(XMPPMessageArchiveManagement *)xmppMessageArchiveManagement didFailToReceiveFormFields:(XMPPIQ *)iq {

    DDLogError(@"MAM didFailToReceiveFormFields: %@", iq.prettyXMLString);

}

@end

@property (nonatomic, strong, nullable) YapDatabaseConnection * databaseConnection;

- (instancetype)init {

    if (self = [super init]) {

        OTRXMPPRoomYapStorage *storage = [[OTRXMPPRoomYapStorage alloc] initWithDatabaseConnection:self.databaseConnection];

//

//  OTRXMPPRoomYapStorage.h

//  ChatSecure

//

//  Created by David Chiles on 10/7/15.

//  Copyright © 2015 Chris Ballinger. All rights reserved.

//

@import Foundation;

@import XMPPFramework;

@import YapDatabase;

#import "OTRIncomingMessage.h"

#import "OTROutgoingMessage.h"

@class OTRXMPPRoomOccupant;

NS_ASSUME_NONNULL_BEGIN

@interface OTRXMPPRoomYapStorage : NSObject <XMPPRoomStorage>

@property (nonatomic, strong) YapDatabaseConnection *databaseConnection;

- (instancetype)initWithDatabaseConnection:(YapDatabaseConnection *)databaseConnection;

- (id <OTRMessageProtocol>)lastMessageInRoom:(XMPPRoom *)room accountKey:(NSString *)accountKey;

@end

NS_ASSUME_NONNULL_END

//

//  OTRXMPPRoomYapStorage.m

//  ChatSecure

//

//  Created by David Chiles on 10/7/15.

//  Copyright © 2015 Chris Ballinger. All rights reserved.

//

#import "OTRXMPPRoomYapStorage.h"

#import "OTRDatabaseManager.h"

#import "OTRAccount.h"

#import <ChatSecureCore/ChatSecureCore-Swift.h>

#import "OTRLog.h"

#import "OTRXMPPManager_Private.h"

@import YapDatabase;

@import XMPPFramework;

@interface OTRXMPPRoomYapStorage ()

@property (nonatomic) dispatch_queue_t parentQueue;

@end

@implementation OTRXMPPRoomYapStorage

- (instancetype)initWithDatabaseConnection:(YapDatabaseConnection *)databaseConnection

{

    if (self = [self init]){

        self.databaseConnection = databaseConnection;

    }

    return self;

}

- (OTRXMPPRoom *)fetchRoomWithXMPPRoomJID:(NSString *)roomJID accountId:(NSString *)accountId inTransaction:(YapDatabaseReadTransaction *)transaction {

    return [OTRXMPPRoom fetchObjectWithUniqueID:[OTRXMPPRoom createUniqueId:accountId jid:roomJID] transaction:transaction];

}

- (BOOL)existsMessage:(XMPPMessage *)message from:(XMPPJID *)fromJID stanzaId:(nullable NSString*)stanzaId transaction:(YapDatabaseReadTransaction *)transaction

{

    NSDate *remoteTimestamp = [message delayedDeliveryDate];

    if (!remoteTimestamp)

    {

        // When the xmpp server sends us a room message, it will always timestamp delayed messages.

        // For example, when retrieving the discussion history, all messages will include the original timestamp.

        // If a message doesn't include such timestamp, then we know we're getting it in "real time".

        return NO;

    }

    NSString *elementID = message.elementID;

    __block BOOL result = NO;

    [transaction enumerateMessagesWithElementId:elementID originId:nil stanzaId:stanzaId block:^(id<OTRMessageProtocol> _Nonnull databaseMessage, BOOL * _Null_unspecified stop) {

        //Need to check room JID

        //So if message has same ID and same room jid that's got to be the same message, right?

        if ([databaseMessage isKindOfClass:[OTRXMPPRoomMessage class]]) {

            OTRXMPPRoomMessage *msg = (OTRXMPPRoomMessage *)databaseMessage;

            if ([msg.roomJID isEqualToString:fromJID.bare]) {

                *stop = YES;

                result = YES;

            }}

    }];

    return result;

}

- (void)insertIncomingMessage:(XMPPMessage *)message intoRoom:(XMPPRoom *)room

{

    NSString *accountId = room.xmppStream.tag;

    NSString *roomJID = room.roomJID.bare;

    XMPPJID *fromJID = [message from];

    if (!accountId || !roomJID || !fromJID) {

        return;

    }

    __block OTRXMPPRoomMessage *databaseMessage = nil;

    __block OTRXMPPRoom *databaseRoom = nil;

    __block OTRXMPPAccount *account = nil;

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction * _Nonnull transaction) {

        account = [OTRXMPPAccount fetchObjectWithUniqueID:accountId transaction:transaction];

        // Sends a response receipt when receiving a delivery receipt request

        [OTRXMPPRoomMessage handleDeliveryReceiptRequestWithMessage:message xmppStream:room.xmppStream];

        // Extract XEP-0359 stanza-id

        NSString *stanzaId = [message extractStanzaIdWithAccount:account];

        NSString *originId = message.originId;

        databaseMessage.originId = originId;

        databaseMessage.stanzaId = stanzaId;

        if ([self existsMessage:message from:fromJID stanzaId:stanzaId transaction:transaction]) {

            // This message already exists and shouldn't be inserted

            DDLogVerbose(@"%@: %@ - Duplicate MUC message %@", THIS_FILE, THIS_METHOD, message);

            return;

        }

        databaseRoom = [self fetchRoomWithXMPPRoomJID:roomJID accountId:accountId inTransaction:transaction];

        if(!databaseRoom) {

            databaseRoom = [[OTRXMPPRoom alloc] init];

            databaseRoom.lastRoomMessageId = @""; // Hack to make it show up in list

            databaseRoom.accountUniqueId = accountId;

            databaseRoom.jid = roomJID;

        }

        if (databaseRoom.joined &&

            ([message elementForName:@"x" xmlns:XMPPMUCUserNamespace] ||

            [message elementForName:@"x" xmlns:@"jabber:x:conference"])) {

                DDLogWarn(@"Received invitation to current room: %@", message);

                return;

        }

        databaseMessage = [[OTRXMPPRoomMessage alloc] init];

        databaseMessage.xmppId = [message elementID];

        databaseMessage.messageText = [message body];

        NSDate *messageDate = [message delayedDeliveryDate];

        if (!messageDate) {

            messageDate = [NSDate date];

        }

        databaseMessage.messageDate = messageDate;

        databaseMessage.senderJID = [fromJID full];

        databaseMessage.roomJID = databaseRoom.jid;

        databaseMessage.state = RoomMessageStateReceived;

        databaseMessage.roomUniqueId = databaseRoom.uniqueId;

        databaseRoom.lastRoomMessageId = [databaseMessage uniqueId];

        NSString *activeThreadYapKey = [[OTRAppDelegate appDelegate] activeThreadYapKey];

        if([activeThreadYapKey isEqualToString:databaseMessage.threadId]) {

            databaseMessage.read = YES;

        } else {

            databaseMessage.read = NO;

        }

        [databaseRoom saveWithTransaction:transaction];

        [databaseMessage saveWithTransaction:transaction];

    } completionBlock:^{

        if(databaseMessage) {

            OTRXMPPManager *xmpp = (OTRXMPPManager*)[OTRProtocolManager.shared protocolForAccount:account];

            [xmpp.fileTransferManager createAndDownloadItemsIfNeededWithMessage:databaseMessage readConnection:OTRDatabaseManager.shared.readOnlyDatabaseConnection force:NO];

            // If delayedDeliveryDate is set we are retrieving history. Don't show

            // notifications in that case. Also, don't show notifications for archived

            // rooms.

            if (!message.delayedDeliveryDate && !databaseRoom.isArchived) {

                [[UIApplication sharedApplication] showLocalNotification:databaseMessage];

            }

        }

    }];

}

- (id <OTRMessageProtocol>)lastMessageInRoom:(XMPPRoom *)room accountKey:(NSString *)accountKey

{

    __block id<OTRMessageProtocol> message = nil;

    [self.databaseConnection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {

        OTRXMPPRoom *databaseRoom = [self fetchRoomWithXMPPRoomJID:room.roomJID.bare accountId:accountKey inTransaction:transaction];

        message = [databaseRoom lastMessageWithTransaction:transaction];

    }];

    return message;

}

//MARK: XMPPRoomStorage

- (BOOL)configureWithParent:(XMPPRoom *)aParent queue:(dispatch_queue_t)queue

{

    self.parentQueue = queue;

    return YES;

}

/**

 * Updates and returns the occupant for the given presence element.

 * If the presence type is "available", and the occupant doesn't already exist, then one should be created.

 **/

- (void)handlePresence:(XMPPPresence *)presence room:(XMPPRoom *)room {

    NSString *accountId = room.xmppStream.tag;

    XMPPJID *presenceJID = [presence from];

    DDXMLElement *item = nil;

    DDXMLElement *mucElement = [presence elementForName:@"x" xmlns:XMPPMUCUserNamespace];

    if (mucElement) {

        item = [mucElement elementForName:@"item"];

    }

    if (!item) {

        return; // Unexpected presence format

    }

    XMPPJID *buddyRealJID = nil;

    NSString *buddyJIDString = [item attributeStringValueForName:@"jid"];

    if (buddyJIDString) {

        // Will be nil in anonymous rooms (and semi-anonymous rooms if we are not moderators)

        buddyRealJID = [[XMPPJID jidWithString:buddyJIDString] bareJID];

    }

    NSString *buddyRole = [item attributeStringValueForName:@"role"];

    NSString *buddyAffiliation = [item attributeStringValueForName:@"affiliation"];

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction * _Nonnull transaction) {

        OTRXMPPRoomOccupant *occupant = [OTRXMPPRoomOccupant occupantWithJid:presenceJID realJID:buddyRealJID roomJID:room.roomJID accountId:accountId createIfNeeded:YES transaction:transaction];

        if ([[presence type] isEqualToString:@"unavailable"]) {

            occupant.available = NO; 

        } else {

            occupant.available = YES;

        }

        occupant.jid = [presenceJID full]; // Nicknames can change, so update

        occupant.roomName = [presenceJID resource];

        // Role

        if ([buddyRole isEqualToString:@"moderator"]) {

            occupant.role = RoomOccupantRoleModerator;

        } else if ([buddyRole isEqualToString:@"participant"]) {

            occupant.role = RoomOccupantRoleParticipant;

        } else if ([buddyRole isEqualToString:@"visitor"]) {

            occupant.role = RoomOccupantRoleVisitor;

        } else {

            occupant.role = RoomOccupantRoleNone;

        }

        // Affiliation

        if ([buddyAffiliation isEqualToString:@"owner"]) {

            occupant.affiliation = RoomOccupantAffiliationOwner;

        } else if ([buddyAffiliation isEqualToString:@"admin"]) {

            occupant.affiliation = RoomOccupantAffiliationAdmin;

        } else if ([buddyAffiliation isEqualToString:@"member"]) {

            occupant.affiliation = RoomOccupantAffiliationMember;

        } else if ([buddyAffiliation isEqualToString:@"outcast"]) {

            occupant.affiliation = RoomOccupantAffiliationOutcast;

        } else {

            occupant.affiliation = RoomOccupantAffiliationNone;

        }

        [occupant saveWithTransaction:transaction];

    }];

}

/**

 * Stores or otherwise handles the given message element.

 **/

- (void)handleIncomingMessage:(XMPPMessage *)message room:(XMPPRoom *)room {

    //DDLogVerbose(@"OTRXMPPRoomYapStorage handleIncomingMessage: %@", message);

    XMPPJID *myRoomJID = room.myRoomJID;

    XMPPJID *messageJID = [message from];

    if ([myRoomJID isEqualToJID:messageJID])

    {

        if (![message wasDelayed])

        {

            // Ignore - we already stored message in handleOutgoingMessage:room:

            return;

        }

    }

    //May need to check if the message is unique. Unsure if this is a real problem. Look at XMPPRoomCoreDataStorage.m existsMessage:

    [self insertIncomingMessage:message intoRoom:room];

}

- (void)handleOutgoingMessage:(XMPPMessage *)message room:(XMPPRoom *)room {

    //DDLogVerbose(@"OTRXMPPRoomYapStorage handleOutgoingMessage: %@", message);

}

/**

 * Handles leaving the room, which generally means clearing the list of occupants.

 **/

- (void)handleDidLeaveRoom:(XMPPRoom *)room {

    NSString *roomJID = room.roomJID.bare;

    NSString *accountId = room.xmppStream.tag;

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction * _Nonnull transaction) {

        OTRXMPPRoom *databaseRoom = [self fetchRoomWithXMPPRoomJID:roomJID accountId:accountId inTransaction:transaction];

        databaseRoom.joined = NO;

        [databaseRoom saveWithTransaction:transaction];

    }];

}

- (void)handleDidJoinRoom:(XMPPRoom *)room withNickname:(NSString *)nickname {

    NSString *roomJID = room.roomJID.bare;

    NSString *accountId = room.xmppStream.tag;

    [self.databaseConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction * _Nonnull transaction) {

        OTRXMPPRoom *databaseRoom = [self fetchRoomWithXMPPRoomJID:roomJID accountId:accountId inTransaction:transaction];

        databaseRoom.joined = YES;

        databaseRoom.ownJID = room.myRoomJID.full;

        [databaseRoom saveWithTransaction:transaction];

    }];

}

@end

//

//  OTRYapDatabaseRosterStorage.h

//  Off the Record

//

//  Created by David Chiles on 3/31/14.

//  Copyright (c) 2014 Chris Ballinger. All rights reserved.

//

@import Foundation;

@import XMPPFramework;

@interface OTRYapDatabaseRosterStorage : NSObject <XMPPRosterStorage>

@end

//

//  OTRYapDatabaseRosterStorage.m

//  Off the Record

//

//  Created by David Chiles on 3/31/14.

//  Copyright (c) 2014 Chris Ballinger. All rights reserved.

//

#import "OTRYapDatabaseRosterStorage.h"

@import YapDatabase;

#import "OTRDatabaseManager.h"

#import "OTRLog.h"

#import "OTRXMPPBuddy.h"

#import "OTRXMPPAccount.h"

#import "OTRBuddyCache.h"

#import <ChatSecureCore/ChatSecureCore-Swift.h>

@import OTRAssets;

@interface OTRYapDatabaseRosterStorage ()

@property (nonatomic, strong, readonly, nonnull) YapDatabaseConnection *readConnection;

@property (nonatomic, strong, readonly, nonnull) YapDatabaseConnection *writeConnection;

@end

/**

 The possible values for a subscription value

 https://xmpp.org/rfcs/rfc6121.html#roster-syntax-items-subscription

 */

typedef NS_ENUM(NSInteger, OTRSubscriptionAttribute) {

    OTRSubscriptionAttributeUnknown,

    OTRSubscriptionAttributeNone,

    OTRSubscriptionAttributeTo,

    OTRSubscriptionAttributeFrom,

    OTRSubscriptionAttributeBoth

};

@implementation OTRYapDatabaseRosterStorage

-(instancetype)init

{

    if (self = [super init]) {

        _readConnection = OTRDatabaseManager.shared.readOnlyDatabaseConnection;

        _writeConnection = OTRDatabaseManager.shared.readWriteDatabaseConnection;

    }

    return self;

}

#pragma - mark Helper Methods

/** Turns out buddies are created during account creation before the account object is saved to the database. oh brother */

- (nonnull NSString*)accountUniqueIdForStream:(XMPPStream*)stream {

    NSParameterAssert(stream.tag);

    return stream.tag;

}

- (nullable OTRXMPPBuddy *)fetchBuddyWithJID:(XMPPJID *)jid stream:(XMPPStream *)stream transaction:(YapDatabaseReadTransaction *)transaction

{

    NSString *accountUniqueId = [self accountUniqueIdForStream:stream];

    OTRXMPPBuddy *buddy = [OTRXMPPBuddy fetchBuddyWithJid:jid accountUniqueId:accountUniqueId transaction:transaction];

    return buddy;

}

/** When created, it is still unsaved and must be manually saved within a yap transaction. */

- (nullable OTRXMPPBuddy *)createBuddyWithJID:(XMPPJID *)jid stream:(XMPPStream *)stream {

    NSString *accountUniqueId = [self accountUniqueIdForStream:stream];

    OTRXMPPBuddy *buddy = [[OTRXMPPBuddy alloc] init];

    buddy.username = [jid bare];

    buddy.accountUniqueId = accountUniqueId;

    return buddy;

}

- (nullable OTRXMPPBuddy*) createBuddyFromRosterItem:(NSXMLElement *)rosterItem stream:(XMPPStream *)stream {

    NSString *jidStr = [rosterItem attributeStringValueForName:@"jid"];

    XMPPJID *jid = [[XMPPJID jidWithString:jidStr] bareJID];

    return [self createBuddyWithJID:jid stream:stream];

}

/** Compares two buddy objects to see if there are changes worth saving */

- (BOOL) shouldSaveUpdatedBuddy:(nonnull OTRXMPPBuddy*)buddy oldBuddy:(nullable OTRXMPPBuddy*)oldBuddy {

    NSParameterAssert(buddy);

    if (!buddy) { return NO; }

    if (!oldBuddy) { return YES; }

    NSAssert(buddy.uniqueId == oldBuddy.uniqueId, @"Comparing two different buddies! Noooooooo.");

    if (buddy.uniqueId != oldBuddy.uniqueId) {

        // I guess we should still save if the uniqueId is different

        return YES;

    }

    if (![buddy.displayName isEqualToString:oldBuddy.displayName]) {

        return YES;

    }

    if (buddy.pendingApproval != oldBuddy.pendingApproval) {

        return YES;

    }

    return NO;

}

- (BOOL)existsBuddyWithJID:(XMPPJID *)jid xmppStram:(XMPPStream *)stream

{

    __block BOOL result = NO;

    [self.readConnection readWithBlock:^(YapDatabaseReadTransaction *transaction) {

        OTRBuddy *buddy = [self fetchBuddyWithJID:jid stream:stream transaction:transaction];

        if (buddy) {

            result = YES;

        }

    }];

    return result;

}

- (OTRSubscriptionAttribute)subscriptionAttribute:(NSXMLElement *)item {

    NSString *subscription = [item attributeStringValueForName:@"subscription"];

    if (subscription ==nil || [subscription isEqualToString:@"none"]) {

        return OTRSubscriptionAttributeNone;

    } else if ([subscription isEqualToString:@"to"]) {

        return OTRSubscriptionAttributeTo;

    } else if ([subscription isEqualToString:@"from"]) {

        return OTRSubscriptionAttributeFrom;

    }else if ([subscription isEqualToString:@"both"]) {

        return OTRSubscriptionAttributeBoth;

    }

    return OTRSubscriptionAttributeUnknown;

}

-(BOOL)isPendingApproval:(NSXMLElement *)item

{

    NSString *ask = [item attributeStringValueForName:@"ask"];

    if ([ask isEqualToString:@"subscribe"]) {

        return YES;

    }

    OTRSubscriptionAttribute subscriptionAttribute = [self subscriptionAttribute:item];

    // If you are subscribed to or are mutually subscribed then you are not pending approval.

    if (subscriptionAttribute == OTRSubscriptionAttributeTo || subscriptionAttribute == OTRSubscriptionAttributeBoth) {

        return NO;

    }

    return YES;

}

/** Buddy can be nil, which indicates a new buddy should be saved. */

- (void)updateBuddy:(nullable OTRXMPPBuddy *)buddy withItem:(nonnull NSXMLElement *)item stream:(XMPPStream*)stream

{

    if (!item) { return; }

    BOOL newlyCreatedBuddy = NO;

    if (!buddy) {

        buddy = [self createBuddyFromRosterItem:item stream:stream];

        if (!buddy) {

            return;

        }

        newlyCreatedBuddy = YES;

    }

    // Fixing a potential migration issue from ages past. Maybe can be removed?

    if (![buddy isKindOfClass:[OTRXMPPBuddy class]]) {

        OTRXMPPBuddy *xmppBuddy = [[OTRXMPPBuddy alloc] init];

        [xmppBuddy mergeValuesForKeysFromModel:buddy];

        buddy = xmppBuddy;

        newlyCreatedBuddy = YES;

    }

    OTRXMPPBuddy *newBuddy = [buddy copy];

    NSString *name = [item attributeStringValueForName:@"name"];

    if (name.length) {

        newBuddy.displayName = name;

    }

    newBuddy.pendingApproval = [self isPendingApproval:item];

    // Save if there were changes, or it's a new buddy

    BOOL shouldSave = [self shouldSaveUpdatedBuddy:newBuddy oldBuddy:buddy] || newlyCreatedBuddy;

    if (!shouldSave) {

        return;

    }

    [self.writeConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

        [newBuddy saveWithTransaction:transaction];

    }];

    if (buddy.pendingApproval && !newBuddy.pendingApproval) {

        // Buddy has approved us

        [[NSNotificationCenter defaultCenter] postNotificationName:OTRBuddyPendingApprovalDidChangeNotification object:self userInfo:@{@"buddy": newBuddy}];

    }

}

#pragma - mark XMPPRosterStorage Methods

- (BOOL)configureWithParent:(XMPPRoster *)aParent queue:(dispatch_queue_t)queue

{

    return YES;

}

- (void)beginRosterPopulationForXMPPStream:(XMPPStream *)stream withVersion:(NSString *)version

{

    DDLogVerbose(@"%@ - %@",THIS_FILE,THIS_METHOD);

}

- (void)endRosterPopulationForXMPPStream:(XMPPStream *)stream

{

    DDLogVerbose(@"%@ - %@",THIS_FILE,THIS_METHOD);

}

- (void)handleRosterItem:(NSXMLElement *)item xmppStream:(XMPPStream *)stream

{

    DDLogVerbose(@"%@ - %@",THIS_FILE,THIS_METHOD);

    NSString *jidStr = [item attributeStringValueForName:@"jid"];

    XMPPJID *jid = [[XMPPJID jidWithString:jidStr] bareJID];

    if([[jid bare] isEqualToString:[[stream myJID] bare]])

    {

        // ignore self buddy

        return;

    }

    __block OTRXMPPBuddy *buddy = nil;

    [self.readConnection readWithBlock:^(YapDatabaseReadTransaction * _Nonnull transaction) {

        buddy = [self fetchBuddyWithJID:jid stream:stream transaction:transaction];

    }];

    NSString *subscription = [item attributeStringValueForName:@"subscription"];

    if ([subscription isEqualToString:@"remove"])

    {

        if (buddy) {

            [self.writeConnection asyncReadWriteWithBlock:^(YapDatabaseReadWriteTransaction *transaction) {

                [transaction removeObjectForKey:buddy.uniqueId inCollection:[OTRXMPPBuddy collection]];

            }];

        }