Add a command-line tool that can generate and apply a binary delta be…

…tween two versions of an application.

The delta file is a custom format created from the xar container format.  It describes the necessary
modifications to transform the contents of the old directory in to the contents of the new.  Binary
diffs are used to compress the differences between large files such as Mach-O binaries.  The binary
diffs are generated by bsdiff and applied via bspatch, both from bsdiff 4.3, the source of which is
included and used under a BSD-style license.

Configurations/ConfigBinaryDelta.xcconfig

@@ -0,0 +1,5 @@
+// BinaryDelta tool only
+
+PRODUCT_NAME = BinaryDelta
+GCC_PREFIX_HEADER =
+SDKROOT = macosx10.6

Configurations/ConfigBinaryDeltaDebug.xcconfig

@@ -0,0 +1,5 @@
+#include "ConfigCommon.xcconfig"
+#include "ConfigCommonDebug.xcconfig"
+#include "ConfigBinaryDelta.xcconfig"
+
+OTHER_CFLAGS = -fsingle-precision-constant -DDEBUG

Configurations/ConfigBinaryDeltaRelease.xcconfig

@@ -0,0 +1,3 @@
+#include "ConfigCommon.xcconfig"
+#include "ConfigCommonRelease.xcconfig"
+#include "ConfigBinaryDelta.xcconfig"

License.txt

@@ -123,4 +123,31 @@ Original SSLeay License
 * derivative of this code cannot be changed.  i.e. this code cannot simply be 
 * copied and put under another distribution licence 
 * [including the GNU Public Licence.] 
-*/
+*/
+
+License for bspatch.c and bsdiff.c, from bsdiff 4.3 (<http://www.daemonology.net/bsdiff/>:
+/*-
+ * Copyright 2003-2005 Colin Percival
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted providing that the following conditions 
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+ * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */

SUBinaryDeltaApply.h

@@ -0,0 +1,15 @@
+//
+//  SUBinaryDeltaApply.h
+//  Sparkle
+//
+//  Created by Mark Rowe on 2009-06-01.
+//  Copyright 2009 Mark Rowe. All rights reserved.
+//
+
+#ifndef SUBINARYDELTAAPPLY_H
+#define SUBINARYDELTAAPPLY_H
+
+@class NSString;
+int applyBinaryDelta(NSString *source, NSString *destination, NSString *patchFile);
+
+#endif

SUBinaryDeltaApply.m

@@ -0,0 +1,101 @@
+//
+//  SUBinaryDeltaApply.m
+//  Sparkle
+//
+//  Created by Mark Rowe on 2009-06-01.
+//  Copyright 2009 Mark Rowe. All rights reserved.
+//
+
+#include "SUBinaryDeltaCommon.h"
+#include <CommonCrypto/CommonDigest.h>
+#include <Foundation/Foundation.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <xar/xar.h>
+
+extern int bspatch(int argc, const char **argv);
+
+static void applyBinaryDeltaToFile(xar_t x, xar_file_t file, NSString *sourceFilePath, NSString *destinationFilePath)
+{
+    NSString *patchFile = temporaryFilename(@"apply-binary-delta");
+    xar_extract_tofile(x, file, [patchFile fileSystemRepresentation]);
+    const char *argv[] = {"/usr/bin/bspatch", [sourceFilePath fileSystemRepresentation], [destinationFilePath fileSystemRepresentation], [patchFile fileSystemRepresentation]};
+    bspatch(4, argv);
+    unlink([patchFile fileSystemRepresentation]);
+}
+
+int applyBinaryDelta(NSString *source, NSString *destination, NSString *patchFile)
+{
+    xar_t x = xar_open([patchFile UTF8String], READ);
+    if (!x) {
+        fprintf(stderr, "Unable to open %s. Giving up.\n", [patchFile UTF8String]);
+        return 1;
+    }
+
+    NSString *expectedBeforeHash = nil;
+    NSString *expectedAfterHash = nil;
+    xar_subdoc_t subdoc;
+    for (subdoc = xar_subdoc_first(x); subdoc; subdoc = xar_subdoc_next(subdoc)) {
+        if (!strcmp(xar_subdoc_name(subdoc), "binary-delta-attributes")) {
+            const char *value = 0;
+            xar_subdoc_prop_get(subdoc, "before-sha1", &value);
+            if (value)
+                expectedBeforeHash = [NSString stringWithUTF8String:value];
+
+            xar_subdoc_prop_get(subdoc, "after-sha1", &value);
+            if (value)
+                expectedAfterHash = [NSString stringWithUTF8String:value];
+        }
+    }
+
+    if (!expectedBeforeHash || !expectedAfterHash) {
+        fprintf(stderr, "Unable to find before-sha1 or after-sha1 metadata in delta.  Giving up.\n");
+        return 1;
+    }
+
+    fprintf(stderr, "Verifying source...  ");
+    NSString *beforeHash = hashOfTree(source);
+
+    if (![beforeHash isEqualToString:expectedBeforeHash]) {
+        fprintf(stderr, "Source doesn't have expected hash (%s != %s).  Giving up.\n", [expectedBeforeHash UTF8String], [beforeHash UTF8String]);
+        return 1;
+    }
+
+    fprintf(stderr, "\nCopying files...  ");
+    removeTree(destination);
+    copyTree(source, destination);
+
+    fprintf(stderr, "\nPatching... ");
+    xar_file_t file;
+    xar_iter_t iter = xar_iter_new();
+    for (file = xar_file_first(x, iter); file; file = xar_file_next(iter)) {
+        NSString *path = [NSString stringWithUTF8String:xar_get_path(file)];
+        NSString *sourceFilePath = [source stringByAppendingPathComponent:path];
+        NSString *destinationFilePath = [destination stringByAppendingPathComponent:path];
+
+        const char *value;
+        if (!xar_prop_get(file, "delete", &value) || !xar_prop_get(file, "delete-then-extract", &value)) {
+            removeTree(destinationFilePath);
+            if (!xar_prop_get(file, "delete", &value))
+                continue;
+        }
+
+        if (!xar_prop_get(file, "binary-delta", &value))
+            applyBinaryDeltaToFile(x, file, sourceFilePath, destinationFilePath);
+        else
+            xar_extract_tofile(x, file, [destinationFilePath fileSystemRepresentation]);
+    }
+    xar_close(x);
+
+    fprintf(stderr, "\nVerifying destination...  ");
+    NSString *afterHash = hashOfTree(destination);
+
+    if (![afterHash isEqualToString:expectedAfterHash]) {
+        fprintf(stderr, "Destination doesn't have expected hash (%s != %s).  Giving up.\n", [expectedAfterHash UTF8String], [afterHash UTF8String]);
+        removeTree(destination);
+        return 1;
+    }
+
+    fprintf(stderr, "\nDone!\n");
+    return 0;
+}

SUBinaryDeltaCommon.h

@@ -0,0 +1,25 @@
+//
+//  SUBinaryDeltaCommon.h
+//  Sparkle
+//
+//  Created by Mark Rowe on 2009-06-01.
+//  Copyright 2009 Mark Rowe. All rights reserved.
+//
+
+#ifndef SUBINARYDELTACOMMON_H
+#define SUBINARYDELTACOMMON_H
+
+#include <fts.h>
+
+@class NSString;
+@class NSData;
+
+extern int compareFiles(const FTSENT **a, const FTSENT **b);
+extern NSData *hashOfFile(FTSENT *ent);
+extern NSString *hashOfTree(NSString *path);
+extern void removeTree(NSString *path);
+extern void copyTree(NSString *source, NSString *dest);
+extern NSString *pathRelativeToDirectory(NSString *directory, NSString *path);
+NSString *temporaryFilename(NSString *base);
+
+#endif

SUBinaryDeltaCommon.m

@@ -0,0 +1,150 @@
+//
+//  SUBinaryDeltaCommon.m
+//  Sparkle
+//
+//  Created by Mark Rowe on 2009-06-01.
+//  Copyright 2009 Mark Rowe. All rights reserved.
+//
+
+#include "SUBinaryDeltaCommon.h"
+#include <CommonCrypto/CommonDigest.h>
+#include <Foundation/Foundation.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+
+int compareFiles(const FTSENT **a, const FTSENT **b)
+{
+    return strcoll((*a)->fts_name, (*b)->fts_name);
+}
+
+NSString *pathRelativeToDirectory(NSString *directory, NSString *path)
+{
+    NSUInteger directoryLength = [directory length];
+    if ([path hasPrefix:directory])
+        return [path substringFromIndex:directoryLength];
+
+    return path;
+}
+
+NSString *temporaryFilename(NSString *base)
+{
+    NSString *template = [NSTemporaryDirectory() stringByAppendingPathComponent:[NSString stringWithFormat:@"%@.XXXXXXXXXX", base]];
+    char buffer[MAXPATHLEN];
+    strcpy(buffer, [template fileSystemRepresentation]);
+    return [NSString stringWithUTF8String:mktemp(buffer)];
+}
+
+static void _hashOfBuffer(unsigned char *hash, const char* buffer, size_t bufferLength)
+{
+    assert(bufferLength <= UINT32_MAX);
+    CC_SHA1_CTX hashContext;
+    CC_SHA1_Init(&hashContext);
+    CC_SHA1_Update(&hashContext, buffer, (CC_LONG)bufferLength);
+    CC_SHA1_Final(hash, &hashContext);
+}
+
+static void _hashOfFile(unsigned char* hash, FTSENT *ent)
+{
+    if (ent->fts_info == FTS_SL) {
+        char linkDestination[MAXPATHLEN + 1];
+        size_t linkDestinationLength = readlink(ent->fts_path, linkDestination, MAXPATHLEN);
+        if (linkDestinationLength < 0) {
+            perror("readlink");
+            return;
+        }
+
+        _hashOfBuffer(hash, linkDestination, linkDestinationLength);
+        return;
+    }
+
+    if (ent->fts_info == FTS_F) {
+        int fileDescriptor = open(ent->fts_path, O_RDONLY);
+        if (fileDescriptor == -1) {
+            perror("open");
+            return;
+        }
+
+        size_t fileSize = ent->fts_statp->st_size;
+        void *buffer = mmap(0, fileSize, PROT_READ, MAP_FILE | MAP_PRIVATE, fileDescriptor, 0);
+        if (buffer == (void*)-1) {
+            close(fileDescriptor);
+            perror("mmap");
+            return;
+        }
+
+        _hashOfBuffer(hash, buffer, fileSize);
+        munmap(buffer, fileSize);
+        close(fileDescriptor);
+        return;
+    }
+
+    if (ent->fts_info == FTS_D)
+        memset(hash, 0xdd, CC_SHA1_DIGEST_LENGTH);
+}
+
+NSData *hashOfFile(FTSENT *ent)
+{
+    unsigned char fileHash[CC_SHA1_DIGEST_LENGTH];
+    _hashOfFile(fileHash, ent);
+    return [NSData dataWithBytes:fileHash length:CC_SHA1_DIGEST_LENGTH];
+}
+
+NSString *hashOfTree(NSString *path)
+{
+    const char *sourcePaths[] = {[path UTF8String], 0};
+    FTS *fts = fts_open((char* const*)sourcePaths, FTS_PHYSICAL | FTS_NOCHDIR, compareFiles);
+    if (!fts) {
+        perror("fts_open");
+        return nil;
+    }
+
+    CC_SHA1_CTX hashContext;
+    CC_SHA1_Init(&hashContext);
+
+    FTSENT *ent = 0;
+    while ((ent = fts_read(fts))) {
+        if (ent->fts_info != FTS_F && ent->fts_info != FTS_SL)
+            continue;
+
+        unsigned char fileHash[CC_SHA1_DIGEST_LENGTH];
+        _hashOfFile(fileHash, ent);
+        CC_SHA1_Update(&hashContext, fileHash, sizeof(fileHash));
+
+        NSString *relativePath = pathRelativeToDirectory(path, [NSString stringWithUTF8String:ent->fts_path]);
+        NSData *relativePathBytes = [relativePath dataUsingEncoding:NSUTF8StringEncoding];
+        CC_SHA1_Update(&hashContext, [relativePathBytes bytes], (uint32_t)[relativePathBytes length]);
+    }
+    fts_close(fts);
+
+    unsigned char hash[CC_SHA1_DIGEST_LENGTH];
+    CC_SHA1_Final(hash, &hashContext);
+
+    char hexHash[CC_SHA1_DIGEST_LENGTH * 2 + 1];
+    size_t i;
+    for (i = 0; i < CC_SHA1_DIGEST_LENGTH; i++)
+        sprintf(hexHash + i * 2, "%02x", hash[i]);
+
+    return [NSString stringWithUTF8String:hexHash];
+}
+
+void removeTree(NSString *path)
+{
+#if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4
+    [[NSFileManager defaultManager] removeItemAtPath:path error:0];
+#else
+    [[NSFileManager defaultManager] removeFileAtPath:path handler:nil];
+#endif
+}
+
+void copyTree(NSString *source, NSString *dest)
+{
+#if MAC_OS_X_VERSION_MIN_REQUIRED > MAC_OS_X_VERSION_10_4
+    [[NSFileManager defaultManager] copyItemAtPath:source toPath:dest error:0];
+#else
+    [[NSFileManager defaultManager] copyPath:source toPath:dest handler:nil];
+#endif    
+}