--- /dev/null
+/*
+ * Copyright (c) 2012-2014 Apple Inc. All Rights Reserved.
+ *
+ * @APPLE_LICENSE_HEADER_START@
+ *
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this
+ * file.
+ *
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
+ * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.
+ *
+ * @APPLE_LICENSE_HEADER_END@
+ */
+
+
+/*
+ * SOSPeer.c - Implementation of a secure object syncing peer
+ */
+#include <SecureObjectSync/SOSPeer.h>
+
+#include <SecureObjectSync/SOSCoder.h>
+#include <SecureObjectSync/SOSDigestVector.h>
+#include <SecureObjectSync/SOSEngine.h>
+#include <SecureObjectSync/SOSFullPeerInfo.h>
+#include <SecureObjectSync/SOSInternal.h>
+#include <SecureObjectSync/SOSPeerInfo.h>
+#include <SecureObjectSync/SOSTransport.h>
+#include <CommonCrypto/CommonDigest.h>
+#include <CommonCrypto/CommonDigestSPI.h>
+#include <utilities/SecCFError.h>
+#include <utilities/SecCFRelease.h>
+#include <utilities/SecCFWrappers.h>
+#include <utilities/SecDb.h>
+#include <utilities/SecFileLocations.h>
+#include <utilities/SecIOFormat.h>
+#include <utilities/array_size.h>
+#include <utilities/debugging.h>
+#include <utilities/der_plist.h>
+#include <utilities/der_plist_internal.h>
+
+#include <securityd/SOSCloudCircleServer.h>
+
+#include <CoreFoundation/CoreFoundation.h>
+
+#include <stdlib.h>
+
+#include <AssertMacros.h>
+
+//
+// MARK: - SOSPeerPersistence code
+//
+static CFStringRef kSOSPeerSequenceNumberKey = CFSTR("sequence-number");
+static CFStringRef kSOSPeerGetObjectsKey = CFSTR("get-objects");
+static CFStringRef kSOSPeerReceivedUnknownConfirmedDigestKey = CFSTR("received-unknown");
+static CFStringRef kSOSPeerJoinRequestedKey = CFSTR("join-requested");
+static CFStringRef kSOSPeerSkipHelloKey = CFSTR("skip-hello");
+
+CFStringRef kSOSPeerDataLabel = CFSTR("iCloud Peer Data Meta-data");
+
+//
+// MARK: SOSPeerState (dictionary keys)
+//
+
+// PeerState dictionary keys
+static CFStringRef kSOSPeerSendObjectsKey = CFSTR("send-objects"); // bool
+static CFStringRef kSOSPeerMustSendMessageKey = CFSTR("must-send"); // bool
+static CFStringRef kSOSPeerPendingObjectsKey = CFSTR("pending-objects"); // digest
+static CFStringRef kSOSPeerPendingDeletesKey = CFSTR("pending-deletes"); // digest
+static CFStringRef kSOSPeerConfirmedManifestKey = CFSTR("confirmed-manifest"); //digest
+static CFStringRef kSOSPeerProposedManifestKey = CFSTR("pending-manifest"); // array of digests
+static CFStringRef kSOSPeerLocalManifestKey = CFSTR("local-manifest"); // array of digests
+static CFStringRef kSOSPeerVersionKey = CFSTR("version"); // int
+
+enum {
+ kSOSPeerMaxManifestWindowDepth = 4
+};
+
+//
+// MARK: - SOSPeer
+//
+
+struct __OpaqueSOSPeer {
+ CFRuntimeBase _base;
+ SOSEngineRef engine;
+
+ SOSCoderRef coder;
+ CFStringRef peer_id;
+ CFIndex version;
+ uint64_t sequenceNumber;
+ bool mustSendMessage;
+};
+
+CFGiblisWithCompareFor(SOSPeer)
+
+static CFStringRef SOSManifestCreateOptionalDescriptionWithLabel(SOSManifestRef manifest, CFStringRef label) {
+ if (!manifest) return CFSTR(" - ");
+ //return CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("%@[%zu]"), label, SOSManifestGetCount(manifest));
+ return CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR(" %@%@"), label, manifest);
+}
+
+static CFMutableDictionaryRef SOSPeerGetState(SOSPeerRef peer) {
+ return SOSEngineGetPeerState(peer->engine, peer->peer_id);
+}
+
+static CFStringRef SOSPeerCreateManifestArrayDescriptionWithKey(SOSPeerRef peer, CFStringRef key, CFStringRef label) {
+ CFMutableArrayRef digests = (CFMutableArrayRef)CFDictionaryGetValue(SOSPeerGetState(peer), key);
+ CFIndex count = digests ? CFArrayGetCount(digests) : 0;
+ if (count == 0) return CFSTR(" - ");
+ CFDataRef digest = CFArrayGetValueAtIndex(digests, 0);
+ return CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR(" %@[%" PRIdCFIndex "]%@"), label, count, SOSEngineGetManifestForDigest(peer->engine, digest));
+}
+
+static CFStringRef SOSPeerCopyDescription(CFTypeRef cf) {
+ SOSPeerRef peer = (SOSPeerRef)cf;
+ if(peer){
+ CFStringRef po = SOSManifestCreateOptionalDescriptionWithLabel(SOSPeerGetPendingObjects(peer), CFSTR("O"));
+ CFStringRef de = SOSManifestCreateOptionalDescriptionWithLabel(SOSPeerGetPendingDeletes(peer), CFSTR("D"));
+ CFStringRef co = SOSManifestCreateOptionalDescriptionWithLabel(SOSPeerGetConfirmedManifest(peer), CFSTR("C"));
+ CFStringRef pe = SOSPeerCreateManifestArrayDescriptionWithKey(peer, kSOSPeerProposedManifestKey, CFSTR("P"));
+ CFStringRef lo = SOSPeerCreateManifestArrayDescriptionWithKey(peer, kSOSPeerLocalManifestKey, CFSTR("L"));
+ CFStringRef desc = CFStringCreateWithFormat(kCFAllocatorDefault, NULL, CFSTR("<%@ %s%s%@%@%@%@%@>"),
+ SOSPeerGetID(peer),
+ SOSPeerMustSendMessage(peer) ? "F" : "f",
+ SOSPeerSendObjects(peer) ? "S" : "s",
+ po, de, co, pe, lo);
+ CFReleaseSafe(lo);
+ CFReleaseSafe(pe);
+ CFReleaseSafe(co);
+ CFReleaseSafe(de);
+ CFReleaseSafe(po);
+
+ return desc;
+ }
+ else
+ return CFSTR("NULL");
+}
+
+static Boolean SOSPeerCompare(CFTypeRef cfA, CFTypeRef cfB)
+{
+ SOSPeerRef peerA = (SOSPeerRef)cfA, peerB = (SOSPeerRef)cfB;
+ // Use mainly to see if peerB is actually this device (peerA)
+ return CFStringCompare(SOSPeerGetID(peerA), SOSPeerGetID(peerB), 0) == kCFCompareEqualTo;
+}
+
+static CFMutableArrayRef SOSPeerGetDigestsWithKey(SOSPeerRef peer, CFStringRef key) {
+ CFMutableDictionaryRef peerState = SOSPeerGetState(peer);
+ CFMutableArrayRef digests = (CFMutableArrayRef)CFDictionaryGetValue(peerState, key);
+ if (!digests) {
+ digests = CFArrayCreateMutableForCFTypes(kCFAllocatorDefault);
+ CFDictionarySetValue(peerState, key, digests);
+ CFReleaseSafe(digests);
+ }
+ return digests;
+}
+
+static void SOSPeerStateSetDigestForKey(CFMutableDictionaryRef peerState, CFStringRef key, CFDataRef digest) {
+ if (digest)
+ CFDictionarySetValue(peerState, key, digest);
+ else
+ CFDictionaryRemoveValue(peerState, key);
+}
+
+static void SOSPeerAddManifestWithKey(SOSPeerRef peer, CFStringRef key, SOSManifestRef manifest) {
+ CFMutableArrayRef digests = SOSPeerGetDigestsWithKey(peer, key);
+ CFDataRef digest = SOSManifestGetDigest(manifest, NULL);
+ if (digest) {
+ CFIndex count = CFArrayGetCount(digests);
+ SOSEngineAddManifest(peer->engine, manifest);
+ CFIndex ixOfDigest = CFArrayGetFirstIndexOfValue(digests, CFRangeMake(0, count), digest);
+ if (ixOfDigest != 0) {
+ if (ixOfDigest != kCFNotFound) {
+ CFArrayRemoveValueAtIndex(digests, ixOfDigest);
+ } else {
+ while (count >= kSOSPeerMaxManifestWindowDepth)
+ CFArrayRemoveValueAtIndex(digests, --count);
+ }
+
+ CFArrayInsertValueAtIndex(digests, 0, digest);
+ }
+ } else {
+ // pending == NULL => nothing clear history
+ CFArrayRemoveAllValues(digests);
+ }
+}
+
+static SOSPeerRef SOSPeerCreate_Internal(SOSEngineRef engine, CFDictionaryRef persisted, CFStringRef theirPeerID, CFIndex version, CFErrorRef *error) {
+ SOSPeerRef p = CFTypeAllocate(SOSPeer, struct __OpaqueSOSPeer, kCFAllocatorDefault);
+ p->engine = engine;
+ p->peer_id = CFRetainSafe(theirPeerID);
+ p->version = version;
+
+ if (persisted) {
+ CFDictionaryRef peer_dict = (CFDictionaryRef) persisted;
+
+ int64_t sequenceNumber;
+ CFNumberRef seqNo = CFDictionaryGetValue(peer_dict, kSOSPeerSequenceNumberKey);
+ if (seqNo) {
+ CFNumberGetValue(seqNo, kCFNumberSInt64Type, &sequenceNumber);
+ p->sequenceNumber = sequenceNumber;
+ }
+ CFNumberRef version = CFDictionaryGetValue(peer_dict, kSOSPeerVersionKey);
+ if (version)
+ CFNumberGetValue(version, kCFNumberCFIndexType, &p->version);
+ }
+
+ return p;
+}
+
+SOSPeerRef SOSPeerCreateWithEngine(SOSEngineRef engine, CFStringRef peer_id) {
+ CFMutableDictionaryRef state = SOSEngineGetPeerState(engine, peer_id);
+ return SOSPeerCreate_Internal(engine, state, peer_id, 0, NULL);
+}
+
+static bool SOSPeerPersistData(SOSPeerRef peer, CFErrorRef *error)
+{
+ CFMutableDictionaryRef data_dict = SOSPeerGetState(peer);
+
+ int64_t sequenceNumber = peer->sequenceNumber;
+ CFNumberRef seqNo = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt64Type, &sequenceNumber);
+ CFDictionarySetValue(data_dict, kSOSPeerSequenceNumberKey, seqNo);
+ CFReleaseNull(seqNo);
+ CFDictionarySetValue(data_dict, kSOSPeerMustSendMessageKey, peer->mustSendMessage ? kCFBooleanTrue : kCFBooleanFalse);
+ if (peer->version) {
+ CFNumberRef version = CFNumberCreate(kCFAllocatorDefault, kCFNumberCFIndexType, &peer->version);
+ CFDictionarySetValue(data_dict, kSOSPeerVersionKey, version);
+ CFReleaseSafe(version);
+ }
+ return true;
+}
+
+SOSPeerRef SOSPeerCreate(SOSEngineRef engine, SOSPeerInfoRef peerInfo,
+ CFErrorRef *error) {
+ if (peerInfo == NULL) {
+ SOSCreateError(kSOSErrorUnsupported, CFSTR("Can't create peer without their peer info!"), NULL, error);
+ return NULL;
+ }
+
+ CFStringRef peer_id = SOSPeerInfoGetPeerID(peerInfo);
+ CFDictionaryRef persisted = SOSEngineGetPeerState(engine, peer_id);
+ SOSPeerRef peer = SOSPeerCreate_Internal(engine,
+ persisted,
+ peer_id,
+ SOSPeerInfoGetVersion(peerInfo),
+ error);
+ if (peer)
+ SOSPeerPersistData(peer, error);
+ return peer;
+}
+
+SOSPeerRef SOSPeerCreateSimple(SOSEngineRef engine, CFStringRef peer_id, CFIndex version, CFErrorRef *error) {
+
+ CFDictionaryRef persisted = SOSEngineGetPeerState(engine, peer_id);
+ SOSPeerRef peer = SOSPeerCreate_Internal(engine, persisted, peer_id, version, error);
+ if (peer)
+ SOSPeerPersistData(peer, error);
+ return peer;
+}
+
+static void SOSPeerDestroy(CFTypeRef cf) {
+ SOSPeerRef peer = (SOSPeerRef)cf;
+ SOSPeerPersistData(peer, NULL);
+ CFReleaseSafe(peer->peer_id);
+}
+
+void SOSPeerDidConnect(SOSPeerRef peer) {
+ SOSPeerSetMustSendMessage(peer, true);
+ SOSPeerSetProposedManifest(peer, SOSPeerGetConfirmedManifest(peer));
+}
+
+CFIndex SOSPeerGetVersion(SOSPeerRef peer) {
+ return peer->version;
+}
+
+CFStringRef SOSPeerGetID(SOSPeerRef peer) {
+ return peer->peer_id;
+}
+
+SOSEngineRef SOSPeerGetEngine(SOSPeerRef peer){
+ return peer->engine;
+}
+SOSCoderRef SOSPeerGetCoder(SOSPeerRef peer){
+ return peer->coder;
+}
+void SOSPeerSetCoder(SOSPeerRef peer, SOSCoderRef coder){
+ peer->coder = coder;
+}
+
+uint64_t SOSPeerNextSequenceNumber(SOSPeerRef peer) {
+ return ++peer->sequenceNumber;
+}
+
+uint64_t SOSPeerGetMessageVersion(SOSPeerRef peer) {
+ return SOSPeerGetVersion(peer);
+
+}
+
+bool SOSPeerMustSendMessage(SOSPeerRef peer) {
+ CFBooleanRef must = CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerMustSendMessageKey);
+ return must && CFBooleanGetValue(must);
+}
+
+void SOSPeerSetMustSendMessage(SOSPeerRef peer, bool sendMessage) {
+ CFDictionarySetValue(SOSPeerGetState(peer), kSOSPeerMustSendMessageKey, sendMessage ? kCFBooleanTrue : kCFBooleanFalse);
+}
+
+bool SOSPeerSendObjects(SOSPeerRef peer) {
+ CFBooleanRef send = CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerSendObjectsKey);
+ return send && CFBooleanGetValue(send);
+}
+
+void SOSPeerSetSendObjects(SOSPeerRef peer, bool sendObjects) {
+ CFDictionarySetValue(SOSPeerGetState(peer), kSOSPeerSendObjectsKey, sendObjects ? kCFBooleanTrue : kCFBooleanFalse);
+}
+
+SOSManifestRef SOSPeerGetProposedManifest(SOSPeerRef peer) {
+ CFDataRef digest = NULL;
+ CFMutableArrayRef proposedDigests = (CFMutableArrayRef)CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerProposedManifestKey);
+ if (proposedDigests && CFArrayGetCount(proposedDigests) > 0)
+ digest = CFArrayGetValueAtIndex(proposedDigests, 0);
+ return SOSEngineGetManifestForDigest(peer->engine, digest);
+}
+
+#if 0
+static SOSManifestRef SOSPeerGetLocalManifest(SOSPeerRef peer) {
+ CFDataRef digest = NULL;
+ CFMutableArrayRef localDigests = (CFMutableArrayRef)CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerLocalManifestKey);
+ if (localDigests && CFArrayGetCount(localDigests) > 0)
+ digest = CFArrayGetValueAtIndex(localDigests, 0);
+ return SOSEngineGetManifestForDigest(peer->engine, digest);
+}
+#endif
+
+SOSManifestRef SOSPeerGetConfirmedManifest(SOSPeerRef peer) {
+ return SOSEngineGetManifestForDigest(peer->engine, CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerConfirmedManifestKey));
+}
+
+void SOSPeerSetConfirmedManifest(SOSPeerRef peer, SOSManifestRef confirmed) {
+ SOSEngineAddManifest(peer->engine, confirmed);
+ SOSPeerStateSetDigestForKey(SOSPeerGetState(peer), kSOSPeerConfirmedManifestKey, SOSManifestGetDigest(confirmed, NULL));
+
+ // TODO: Clear only expired pending and local manifests from the array - this clears them all
+ // To do so we'd have to track the messageIds we sent to our peer and when we proposed a particular manifest.
+ // Then we simply remove the entires from messages older that the one we are confirming now
+ //CFArrayRemoveAllValues(SOSPeerGetDigestsWithKey(peer, kSOSPeerProposedManifestKey));
+ //CFArrayRemoveAllValues(SOSPeerGetDigestsWithKey(peer, kSOSPeerLocalManifestKey));
+}
+
+void SOSPeerAddProposedManifest(SOSPeerRef peer, SOSManifestRef pending) {
+ SOSPeerAddManifestWithKey(peer, kSOSPeerProposedManifestKey, pending);
+}
+
+void SOSPeerSetProposedManifest(SOSPeerRef peer, SOSManifestRef pending) {
+ SOSEngineAddManifest(peer->engine, pending);
+ CFMutableArrayRef proposedDigests = SOSPeerGetDigestsWithKey(peer, kSOSPeerProposedManifestKey);
+ CFArrayRemoveAllValues(proposedDigests);
+ if (pending)
+ CFArrayAppendValue(proposedDigests, SOSManifestGetDigest(pending, NULL));
+}
+
+void SOSPeerAddLocalManifest(SOSPeerRef peer, SOSManifestRef local) {
+ SOSPeerAddManifestWithKey(peer, kSOSPeerLocalManifestKey, local);
+}
+
+SOSManifestRef SOSPeerGetPendingObjects(SOSPeerRef peer) {
+ return SOSEngineGetManifestForDigest(peer->engine, CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerPendingObjectsKey));
+}
+
+void SOSPeerSetPendingObjects(SOSPeerRef peer, SOSManifestRef pendingObjects) {
+ SOSEngineAddManifest(peer->engine, pendingObjects);
+ SOSPeerStateSetDigestForKey(SOSPeerGetState(peer), kSOSPeerPendingObjectsKey, SOSManifestGetDigest(pendingObjects, NULL));
+}
+
+SOSManifestRef SOSPeerGetPendingDeletes(SOSPeerRef peer) {
+ return SOSEngineGetManifestForDigest(peer->engine, CFDictionaryGetValue(SOSPeerGetState(peer), kSOSPeerPendingDeletesKey));
+}
+
+void SOSPeerSetPendingDeletes(SOSPeerRef peer, SOSManifestRef pendingDeletes) {
+ SOSEngineAddManifest(peer->engine, pendingDeletes);
+ SOSPeerStateSetDigestForKey(SOSPeerGetState(peer), kSOSPeerPendingDeletesKey, SOSManifestGetDigest(pendingDeletes, NULL));
+}
+
+static void SOSMarkDigestInUse(struct SOSDigestVector *mdInUse, CFDataRef digest) {
+ if (!isData(digest)) return;
+ SOSDigestVectorAppend(mdInUse, CFDataGetBytePtr(digest));
+}
+
+static void SOSMarkDigestsInUse(struct SOSDigestVector *mdInUse, CFArrayRef digests) {
+ if (!isArray(digests)) return;
+ CFDataRef digest = NULL;
+ CFArrayForEachC(digests, digest) {
+ SOSMarkDigestInUse(mdInUse, digest);
+ }
+}
+
+// Add all digests we are using to mdInUse
+void SOSPeerMarkDigestsInUse(SOSPeerRef peer, struct SOSDigestVector *mdInUse) {
+ CFMutableDictionaryRef peerState = SOSPeerGetState(peer);
+ SOSMarkDigestInUse(mdInUse, CFDictionaryGetValue(peerState, kSOSPeerPendingObjectsKey));
+ SOSMarkDigestInUse(mdInUse, CFDictionaryGetValue(peerState, kSOSPeerPendingDeletesKey));
+ SOSMarkDigestInUse(mdInUse, CFDictionaryGetValue(peerState, kSOSPeerConfirmedManifestKey));
+ SOSMarkDigestsInUse(mdInUse, CFDictionaryGetValue(peerState, kSOSPeerLocalManifestKey));
+ SOSMarkDigestsInUse(mdInUse, CFDictionaryGetValue(peerState, kSOSPeerProposedManifestKey));
+}
+
+
+// absentFromRemote
+// AbsentLocally
+// additionsFromRemote
+// original intent was that digests only got added to pendingObjects. We only know for sure if it is something added locally via api call
+
+
+bool SOSPeerDidReceiveRemovalsAndAdditions(SOSPeerRef peer, SOSManifestRef absentFromRemote, SOSManifestRef additionsFromRemote,
+ SOSManifestRef local, CFErrorRef *error) {
+ // We assume that incoming manifests are all sorted, and absentFromRemote is disjoint from additionsFromRemote
+ bool ok = true;
+ SOSManifestRef remoteRemovals = NULL, sharedRemovals = NULL, sharedAdditions = NULL, remoteAdditions = NULL;
+ CFDataRef pendingObjectsDigest, pendingDeletesDigest;
+
+ // TODO: Simplyfy -- a lot.
+ ok = ok && (remoteRemovals = SOSManifestCreateIntersection(absentFromRemote, local, error)); // remoteRemovals = absentFromRemote <Intersected> local
+ ok = ok && (sharedRemovals = SOSManifestCreateComplement(remoteRemovals, absentFromRemote, error)); // sharedRemovals = absentFromRemote - remoteRemovals
+ ok = ok && (sharedAdditions = SOSManifestCreateIntersection(additionsFromRemote, local, error)); // sharedAdditions = additionsFromRemote <Intersected> local
+ ok = ok && (remoteAdditions = SOSManifestCreateComplement(sharedAdditions, additionsFromRemote, error)); // remoteAdditions = additionsFromRemote - sharedAdditions
+
+ secnotice("peer", "%@ R:%@ A:%@ C:%@ D:%@ O:%@", peer, absentFromRemote, additionsFromRemote, SOSPeerGetConfirmedManifest(peer), SOSPeerGetPendingDeletes(peer), SOSPeerGetPendingObjects(peer));
+
+ // TODO: Does the value of SOSPeerSendObjects() matter here?
+ pendingObjectsDigest = SOSEnginePatchRecordAndCopyDigest(peer->engine, SOSPeerGetPendingObjects(peer), sharedAdditions, NULL, error); // PO = PO - sharedAdditions
+ pendingDeletesDigest = SOSEnginePatchRecordAndCopyDigest(peer->engine, SOSPeerGetPendingDeletes(peer), sharedRemovals, NULL, error); // D = D - sharedRemovals
+
+ CFMutableDictionaryRef peerState = SOSPeerGetState(peer);
+ SOSPeerStateSetDigestForKey(peerState, kSOSPeerPendingObjectsKey, pendingObjectsDigest);
+ SOSPeerStateSetDigestForKey(peerState, kSOSPeerPendingDeletesKey, pendingDeletesDigest);
+
+ CFReleaseSafe(pendingDeletesDigest);
+ CFReleaseSafe(pendingObjectsDigest);
+ CFReleaseSafe(remoteRemovals);
+ CFReleaseSafe(sharedRemovals);
+ CFReleaseSafe(sharedAdditions);
+ CFReleaseSafe(remoteAdditions);
+
+ secnotice("peer", "%@ C:%@ D:%@ O:%@", peer, SOSPeerGetConfirmedManifest(peer), SOSPeerGetPendingDeletes(peer), SOSPeerGetPendingObjects(peer));
+
+ return ok;
+}
+
+bool SOSPeerDidReceiveConfirmedManifest(SOSPeerRef peer, SOSManifestRef confirmed, SOSManifestRef local, CFErrorRef *error) {
+ bool ok = true;
+ if (!confirmed) return ok;
+ SOSManifestRef confirmedRemovals = NULL, confirmedAdditions = NULL;
+
+ // confirmedAdditions = confirmed - previous_confirmed, confirmedRemovals = previous_confirmed - confirmed
+ ok &= SOSManifestDiff(SOSPeerGetConfirmedManifest(peer), confirmed, &confirmedRemovals, &confirmedAdditions, error);
+ ok &= SOSPeerDidReceiveRemovalsAndAdditions(peer, confirmedRemovals, confirmedAdditions, local, error);
+
+ CFReleaseSafe(confirmedRemovals);
+ CFReleaseSafe(confirmedAdditions);
+ return ok;
+}
+
+bool SOSPeerDataSourceWillCommit(SOSPeerRef peer, SOSDataSourceTransactionSource source, SOSManifestRef removals, SOSManifestRef additions, CFErrorRef *error) {
+ SOSManifestRef unconfirmedAdditions = NULL;
+ CFDataRef pendingObjectsDigest, pendingDeletesDigest = NULL;
+
+ secnotice("peer", "%@ R:%@ A:%@ C:%@ D:%@ O:%@", peer, removals, additions, SOSPeerGetConfirmedManifest(peer), SOSPeerGetPendingDeletes(peer), SOSPeerGetPendingObjects(peer));
+
+ // Remove confirmed from additions
+ // TODO: Add require and check for error
+ unconfirmedAdditions = SOSManifestCreateComplement(SOSPeerGetConfirmedManifest(peer), additions, error);
+ secnotice("peer", "%@ UA: %@ source: %s", peer, unconfirmedAdditions, source == kSOSDataSourceSOSTransaction ? "sos" : "api");
+
+ pendingObjectsDigest = SOSEnginePatchRecordAndCopyDigest(peer->engine, SOSPeerGetPendingObjects(peer), removals, source == kSOSDataSourceAPITransaction ? unconfirmedAdditions : NULL, error);
+ // TODO: Figure out how to update pendingDeletes...
+ //pendingDeletesDigest = SOSEnginePatchRecordAndCopyDigest(peer->engine, SOSPeerGetPendingDeletes(peer), removals, NULL, error);
+
+ CFMutableDictionaryRef peerState = SOSPeerGetState(peer);
+
+ SOSPeerStateSetDigestForKey(peerState, kSOSPeerPendingObjectsKey, pendingObjectsDigest);
+ SOSPeerStateSetDigestForKey(peerState, kSOSPeerPendingDeletesKey, pendingDeletesDigest);
+
+ CFReleaseSafe(pendingDeletesDigest);
+ CFReleaseSafe(pendingObjectsDigest);
+ CFReleaseSafe(unconfirmedAdditions);
+
+ secnotice("peer", "%@ C:%@ D:%@ P:%@", peer, SOSPeerGetConfirmedManifest(peer), SOSPeerGetPendingDeletes(peer), SOSPeerGetPendingObjects(peer));
+
+ return true;
+}
+
projects / apple / security.git / blobdiff