Make the Keystone tag contain -32bit and -full as needed

chrome/browser/mac/keystone_glue.mm

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "chrome/browser/mac/keystone_glue.h"
 
 #include <sys/mount.h>
 #include <sys/param.h>
 #include <sys/stat.h>
+#include <sys/sysctl.h>
+#include <sys/types.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/mac/authorization_util.h"
 #include "base/mac/bundle_locations.h"
 #include "base/mac/mac_logging.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/mac/scoped_nsexception_enabler.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/threading/worker_pool.h"
+#include "build/build_config.h"
 #import "chrome/browser/mac/keystone_registration.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_version_info.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/l10n_util_mac.h"
 
 namespace {
 
@@ skipping 146 matching lines @@
 // -promotionComplete.  That routine calls
 // -changePermissionsForPromotionWithTool: on a work queue thread.  When done,
 // -changePermissionsForPromotionComplete is called on the main thread.
 - (void)changePermissionsForPromotionAsync;
 - (void)changePermissionsForPromotionWithTool:(NSString*)toolPath;
 - (void)changePermissionsForPromotionComplete;
 
 // Returns the brand file path to use for Keystone.
 - (NSString*)brandFilePath;
 
+// YES if the system's CPU is 32-bit-only, NO if it's 64-bit-capable.
+- (BOOL)has32BitOnlyCPU;
+
+// YES if no update installation has succeeded since a binary diff patch
+// installation failed. This signals the need to attempt a full installer
+// which does not depend on applying a patch to existing files.
+- (BOOL)wantsFullInstaller;
+
+// Returns an NSString* suitable for appending to a Chrome Keystone tag value
+// or tag key. If the system has a 32-bit-only CPU, the tag suffix will
+// contain the string "-32bit". If a full installer (as opposed to a binary
+// diff/delta patch) is required, the tag suffix will contain the string
+// "-full". If no special treatment is required, the tag suffix will be an
+// empty string.
+- (NSString*)tagSuffix;
+
 @end  // @interface KeystoneGlue (Private)
 
 NSString* const kAutoupdateStatusNotification = @"AutoupdateStatusNotification";
 NSString* const kAutoupdateStatusStatus = @"status";
 NSString* const kAutoupdateStatusVersion = @"version";
 
 namespace {
 
 NSString* const kChannelKey = @"KSChannelID";
 NSString* const kBrandKey = @"KSBrandID";
@@ skipping 245 matching lines @@
   NSString* appInfoPlistPath = [self appInfoPlistPath];
   NSString* brandKey = kBrandKey;
   NSString* brandPath = [self brandFilePath];
 
   if ([brandPath length] == 0) {
     // Brand path and brand key must be cleared together or ksadmin seems
     // to throw an error.
     brandKey = @"";
   }
 
+  // Note that channel_ is permitted to be an empty string, but it must not be
+  // nil.
+  DCHECK(channel_);
+  NSString* tagSuffix = [self tagSuffix];
+  NSString* tagValue = [channel_ stringByAppendingString:tagSuffix];
+  NSString* tagKey = [kChannelKey stringByAppendingString:tagSuffix];
+
   return [NSDictionary dictionaryWithObjectsAndKeys:
              version_, ksr::KSRegistrationVersionKey,
              appInfoPlistPath, ksr::KSRegistrationVersionPathKey,
              kVersionKey, ksr::KSRegistrationVersionKeyKey,
              xcType, ksr::KSRegistrationExistenceCheckerTypeKey,
              appPath_, ksr::KSRegistrationExistenceCheckerStringKey,
              url_, ksr::KSRegistrationServerURLStringKey,
              preserveTTToken, ksr::KSRegistrationPreserveTrustedTesterTokenKey,
-             channel_, ksr::KSRegistrationTagKey,
+             tagValue, ksr::KSRegistrationTagKey,
              appInfoPlistPath, ksr::KSRegistrationTagPathKey,
-             kChannelKey, ksr::KSRegistrationTagKeyKey,
+             tagKey, ksr::KSRegistrationTagKeyKey,
              brandPath, ksr::KSRegistrationBrandPathKey,
              brandKey, ksr::KSRegistrationBrandKeyKey,
              nil];
 }
 
 - (void)registerWithKeystone {
   [self updateStatus:kAutoupdateRegistering version:nil];
 
   NSDictionary* parameters = [self keystoneParameters];
   BOOL result;
@@ skipping 499 matching lines @@
   [self updateStatus:kAutoupdatePromoted version:nil];
 }
 
 - (void)setAppPath:(NSString*)appPath {
   if (appPath != appPath_) {
     [appPath_ release];
     appPath_ = [appPath copy];
   }
 }
 
+- (BOOL)has32BitOnlyCPU {
+#if defined(ARCH_CPU_64_BITS)
+  return NO;
+#else  // ARCH_CPU_64_BITS
+  int value;
+  size_t valueSize = sizeof(value);
+  if (sysctlbyname("hw.cpu64bit_capable", &value, &valueSize, NULL, 0) != 0) {
+    return YES;
+  }
+  return value == 0;
+#endif  // ARCH_CPU_64_BITS
+}
+
+- (BOOL)wantsFullInstaller {
+  // It's difficult to check the tag prior to Keystone registration, and
+  // performing registration replaces the tag. keystone_install.sh
+  // communicates a need for a full installer with Chrome in this file,
+  // .want_full_installer.
+  NSString* wantFullInstallerPath =
+      [appPath_ stringByAppendingPathComponent:@".want_full_installer"];

[TVL, 2014/01/03 00:09:40]

If you write this into the app, doesn't it mean the codesigning is no longer
valid for the app?  is that ok?

[Mark Mentovai, 2014/01/03 16:46:41]

TVL wrote:
I purposely chose a path that isn’t included in the signature. Signing starts in
Google Chrome.app/Contents. .want_full_installer is outside of Contents, in
Google Chrome.app/.want_full_installer. I tested this and it doesn’t break the
signature.

[TVL, 2014/01/03 19:41:23]

Ah, might be worth a comment in one of the two places this path is used.  I went
digging for the signing info, but couldn't find it quickly.

+  NSString* wantFullInstallerContents =
+      [NSString stringWithContentsOfFile:wantFullInstallerPath
+                                encoding:NSUTF8StringEncoding
+                                   error:NULL];
+  if (!wantFullInstallerContents) {
+    return NO;
+  }
+
+  NSString* wantFullInstallerVersion =
+      [wantFullInstallerContents stringByTrimmingCharactersInSet:
+          [NSCharacterSet newlineCharacterSet]];
+  return [wantFullInstallerVersion isEqualToString:version_];
+}
+
+- (NSString*)tagSuffix {
+  // Tag suffix components are not entirely arbitrary: all possible tag keys
+  // must be present in the application's Info.plist, there must be
+  // server-side agreement on the processing and meaning of tag suffix
+  // components, and other code that manipulates tag values (such as the
+  // Keystone update installation script) must be tag suffix-aware. To reduce
+  // the number of tag suffix combinations that need to be listed in
+  // Info.plist, tag suffix components should only be appended to the tag
+  // suffix in ASCII sort order.
+  NSString* tagSuffix = @"";
+  if ([self has32BitOnlyCPU]) {
+    tagSuffix = [tagSuffix stringByAppendingString:@"-32bit"];
+  }
+  if ([self wantsFullInstaller]) {
+    tagSuffix = [tagSuffix stringByAppendingString:@"-full"];
+  }
+  return tagSuffix;
+}
+
 @end  // @implementation KeystoneGlue
 
 namespace {
 
 std::string BrandCodeInternal() {
   KeystoneGlue* keystone_glue = [KeystoneGlue defaultKeystoneGlue];
   NSString* brand_path = [keystone_glue brandFilePath];
 
   if (![brand_path length])
     return std::string();
@@ skipping 22 matching lines @@
   return [KeystoneGlue defaultKeystoneGlue] != nil;
 }
 
 base::string16 CurrentlyInstalledVersion() {
   KeystoneGlue* keystoneGlue = [KeystoneGlue defaultKeystoneGlue];
   NSString* version = [keystoneGlue currentlyInstalledVersion];
   return base::SysNSStringToUTF16(version);
 }
 
 }  // namespace keystone_glue