Build pref-pane as universal binary on Mac OS X

remoting/host/me2me_preference_pane.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 "remoting/host/me2me_preference_pane.h"
 
 #import <Cocoa/Cocoa.h>
 #include <CommonCrypto/CommonHMAC.h>
+#include <errno.h>
 #include <launch.h>
 #import <PreferencePanes/PreferencePanes.h>
 #import <SecurityInterface/SFAuthorizationView.h>
+#include <stdlib.h>
 #include <unistd.h>
 
 #include <fstream>
 
 #include "base/eintr_wrapper.h"
-#include "base/logging.h"
-#include "base/mac/authorization_util.h"
-#include "base/mac/foundation_util.h"
-#include "base/mac/launchd.h"
-#include "base/mac/mac_logging.h"
 #include "base/mac/scoped_launch_data.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/stringprintf.h"
-#include "base/sys_string_conversions.h"
 #include "remoting/host/host_config.h"
 #include "third_party/jsoncpp/source/include/json/reader.h"
 #include "third_party/jsoncpp/source/include/json/writer.h"
 #include "third_party/modp_b64/modp_b64.h"
 
 namespace {
 // The name of the Remoting Host service that is registered with launchd.
 #define kServiceName "org.chromium.chromoting"
 
 // Use separate named notifications for success and failure because sandboxed
@@ skipping 30 matching lines @@
                 const std::string& host_secret_hash) {
   // TODO(lambroslambrou): Once the "base" target supports building for 64-bit
   // on Mac OS X, remove this code and replace it with |VerifyHostPinHash()|
   // from host/pin_hash.h.
   size_t separator = host_secret_hash.find(':');
   if (separator == std::string::npos)
     return false;
 
   std::string method = host_secret_hash.substr(0, separator);
   if (method != "hmac") {
-    LOG(ERROR) << "Authentication method '" << method << "' not supported";
+    NSLog(@"Authentication method '%s' not supported", method.c_str());
     return false;
   }
 
   std::string hash_base64 = host_secret_hash.substr(separator + 1);
 
   // Convert |hash_base64| to |hash|, based on code from base/base64.cc.
   int hash_base64_size = static_cast<int>(hash_base64.size());
   std::string hash;
   hash.resize(modp_b64_decode_len(hash_base64_size));
   int hash_size = modp_b64_decode(&(hash[0]), hash_base64.data(),
                                   hash_base64_size);
   if (hash_size < 0) {
-    LOG(ERROR) << "Failed to parse host_secret_hash";
+    NSLog(@"Failed to parse host_secret_hash");
     return false;
   }
   hash.resize(hash_size);
 
   std::string computed_hash;
   computed_hash.resize(CC_SHA256_DIGEST_LENGTH);
 
   CCHmac(kCCHmacAlgSHA256,
          host_id.data(), host_id.size(),
          pin.data(), pin.size(),
          &(computed_hash[0]));
 
   return computed_hash == hash;
 }
 
 }  // namespace
 
+// These methods are copied from base/mac, but with the logging changed to use
+// NSLog().
+//
+// TODO(lambroslambrou): Once the "base" target supports building for 64-bit
+// on Mac OS X, remove these implementations and use the ones in base/mac.
+namespace base {
+namespace mac {
+
+// MessageForJob sends a single message to launchd with a simple dictionary
+// mapping |operation| to |job_label|, and returns the result of calling
+// launch_msg to send that message. On failure, returns NULL. The caller
+// assumes ownership of the returned launch_data_t object.
+launch_data_t MessageForJob(const std::string& job_label,
+                            const char* operation) {
+  // launch_data_alloc returns something that needs to be freed.
+  ScopedLaunchData message(launch_data_alloc(LAUNCH_DATA_DICTIONARY));
+  if (!message) {
+    NSLog(@"launch_data_alloc");
+    return NULL;
+  }
+
+  // launch_data_new_string returns something that needs to be freed, but
+  // the dictionary will assume ownership when launch_data_dict_insert is
+  // called, so put it in a scoper and .release() it when given to the
+  // dictionary.
+  ScopedLaunchData job_label_launchd(launch_data_new_string(job_label.c_str()));
+  if (!job_label_launchd) {
+    NSLog(@"launch_data_new_string");
+    return NULL;
+  }
+
+  if (!launch_data_dict_insert(message,
+                               job_label_launchd.release(),
+                               operation)) {
+    return NULL;
+  }
+
+  return launch_msg(message);
+}
+
+pid_t PIDForJob(const std::string& job_label) {

[Robert Sesek, 2012/05/16 14:34:04]

http://code.google.com/codesearch#OAMlx_jo-ck/src/base/mac/launchd.h&exact_pa...

[Robert Sesek, 2012/05/16 14:37:43]

Sorry, just saw your comment. Got confused by seeing other #include "base/..."
files.

Though I thought we supported building base as 64-bit? I tried it a few weeks
ago and it worked by just setting the archs properly.

[Lambros, 2012/05/16 17:43:44]

mark@ told me it works, but it's currently untested and unsupported.  It's
something we want to do, but we'd have to get support from Chrome - it seems a
large change to make to Chrome, just for a small pref-pane application for
Chromoting :)

I will followup with a post to chromium-dev.  In the meantime, I welcome any
suggestions you have.

+  ScopedLaunchData response(MessageForJob(job_label, LAUNCH_KEY_GETJOB));
+  if (!response) {
+    return -1;
+  }
+
+  launch_data_type_t response_type = launch_data_get_type(response);
+  if (response_type != LAUNCH_DATA_DICTIONARY) {
+    if (response_type == LAUNCH_DATA_ERRNO) {
+      NSLog(@"PIDForJob: error %d", launch_data_get_errno(response));
+    } else {
+      NSLog(@"PIDForJob: expected dictionary, got %d", response_type);
+    }
+    return -1;
+  }
+
+  launch_data_t pid_data = launch_data_dict_lookup(response,
+                                                   LAUNCH_JOBKEY_PID);
+  if (!pid_data)
+    return 0;
+
+  if (launch_data_get_type(pid_data) != LAUNCH_DATA_INTEGER) {
+    NSLog(@"PIDForJob: expected integer");
+    return -1;
+  }
+
+  return launch_data_get_integer(pid_data);
+}
+
+OSStatus ExecuteWithPrivilegesAndGetPID(AuthorizationRef authorization,
+                                        const char* tool_path,
+                                        AuthorizationFlags options,
+                                        const char** arguments,
+                                        FILE** pipe,
+                                        pid_t* pid) {
+  // pipe may be NULL, but this function needs one.  In that case, use a local
+  // pipe.
+  FILE* local_pipe;
+  FILE** pipe_pointer;
+  if (pipe) {
+    pipe_pointer = pipe;
+  } else {
+    pipe_pointer = &local_pipe;
+  }
+
+  // AuthorizationExecuteWithPrivileges wants |char* const*| for |arguments|,
+  // but it doesn't actually modify the arguments, and that type is kind of
+  // silly and callers probably aren't dealing with that.  Put the cast here
+  // to make things a little easier on callers.
+  OSStatus status = AuthorizationExecuteWithPrivileges(authorization,
+                                                       tool_path,
+                                                       options,
+                                                       (char* const*)arguments,
+                                                       pipe_pointer);
+  if (status != errAuthorizationSuccess) {
+    return status;
+  }
+
+  long line_pid = -1;
+  size_t line_length = 0;
+  char* line_c = fgetln(*pipe_pointer, &line_length);
+  if (line_c) {
+    if (line_length > 0 && line_c[line_length - 1] == '\n') {
+      // line_c + line_length is the start of the next line if there is one.
+      // Back up one character.
+      --line_length;
+    }
+    std::string line(line_c, line_length);
+
+    // The version in base/mac used base::StringToInt() here.
+    line_pid = strtol(line.c_str(), NULL, 10);
+    if (line_pid == 0) {
+      NSLog(@"ExecuteWithPrivilegesAndGetPid: funny line: %s", line.c_str());
+      line_pid = -1;
+    }
+  } else {
+    NSLog(@"ExecuteWithPrivilegesAndGetPid: no line");
+  }
+
+  if (!pipe) {
+    fclose(*pipe_pointer);
+  }
+
+  if (pid) {
+    *pid = line_pid;
+  }
+
+  return status;
+}
+
+}  // namespace mac
+}  // namespace base
+
 namespace remoting {
 JsonHostConfig::JsonHostConfig(const std::string& filename)
     : filename_(filename) {
 }
 
 JsonHostConfig::~JsonHostConfig() {
 }
 
 bool JsonHostConfig::Read() {
   std::ifstream file(filename_.c_str());
@@ skipping 71 matching lines @@
   if (!have_new_config_) {
     // It shouldn't be possible to hit the button if there is no config to
     // apply, but check anyway just in case it happens somehow.
     return;
   }
 
   // Ensure the authorization token is up-to-date before using it.
   [self updateAuthorizationStatus];
   [self updateUI];
 
-  std::string pin = base::SysNSStringToUTF8([pin_ stringValue]);
+  std::string pin = [[pin_ stringValue] UTF8String];
   std::string host_id, host_secret_hash;
   bool result = (config_->GetString(remoting::kHostIdConfigPath, &host_id) &&
                  config_->GetString(remoting::kHostSecretHashConfigPath,
                                     &host_secret_hash));
-  DCHECK(result);

[Jamie, 2012/05/16 20:31:34]

In changing these DCHECKs, you're changing the Release-build behaviour. I think
what you have now is better, but be aware of the change.

+  if (!result) {
+    [self showError];
+    return;
+  }
   if (!IsPinValid(pin, host_id, host_secret_hash)) {
     [self showIncorrectPinMessage];
     return;
   }
 
   [self applyNewServiceConfig];
   [self updateUI];
 }
 
 - (void)onDisable:(id)sender {
   // Ensure the authorization token is up-to-date before using it.
   [self updateAuthorizationStatus];
   [self updateUI];
   if (!is_pane_unlocked_)
     return;
 
   if (![self runHelperAsRootWithCommand:"--disable"
                               inputData:""]) {
-    LOG(ERROR) << "Failed to run the helper tool";
+    NSLog(@"Failed to run the helper tool");
     [self showError];
     return;
   }
 
   // Stop the launchd job.  This cannot easily be done by the helper tool,
   // since the launchd job runs in the current user's context.
   [self sendJobControlMessage:LAUNCH_KEY_STOPJOB];
 }
 
 - (void)onNewConfigFile:(NSNotification*)notification {
@@ skipping 23 matching lines @@
   is_service_running_ = (job_pid > 0);
 }
 
 - (void)updateAuthorizationStatus {
   is_pane_unlocked_ = [authorization_view_ updateStatus:authorization_view_];
 }
 
 - (void)readNewConfig {
   std::string file;
   if (!GetTemporaryConfigFilePath(&file)) {
-    LOG(ERROR) << "Failed to get path of configuration data.";
+    NSLog(@"Failed to get path of configuration data.");
     [self showError];
     return;
   }
   if (access(file.c_str(), F_OK) != 0)
     return;
 
   scoped_ptr<remoting::JsonHostConfig> new_config_(
       new remoting::JsonHostConfig(file));
   if (!new_config_->Read()) {
     // Report the error, because the file exists but couldn't be read.  The
     // case of non-existence is normal and expected.
-    LOG(ERROR) << "Error reading configuration data from " << file.c_str();
+    NSLog(@"Error reading configuration data from %s", file.c_str());
     [self showError];
     return;
   }
   remove(file.c_str());
   if (!IsConfigValid(new_config_.get())) {
-    LOG(ERROR) << "Invalid configuration data read.";
+    NSLog(@"Invalid configuration data read.");
     [self showError];
     return;
   }
 
   config_.swap(new_config_);
   have_new_config_ = YES;
 }
 
 - (void)updateUI {
   // TODO(lambroslambrou): These strings should be localized.
 #ifdef OFFICIAL_BUILD
   NSString* name = @"Chrome Remote Desktop";
 #else
   NSString* name = @"Chromoting";
 #endif
   NSString* message;
   if (is_service_running_) {
     message = [NSString stringWithFormat:@"%@ is enabled", name];
   } else {
     message = [NSString stringWithFormat:@"%@ is disabled", name];
   }
   [status_message_ setStringValue:message];
 
   std::string email;
   if (config_.get()) {
     bool result = config_->GetString(remoting::kXmppLoginConfigPath, &email);
 
     // The config has already been checked by |IsConfigValid|.
-    DCHECK(result);
+    if (!result) {
+      [self showError];
+      return;
+    }
   }
-  [email_ setStringValue:base::SysUTF8ToNSString(email)];
+  [email_ setStringValue:[NSString stringWithUTF8String:email.c_str()]];
 
   [disable_button_ setEnabled:(is_pane_unlocked_ && is_service_running_)];
   [pin_instruction_message_ setEnabled:have_new_config_];
   [email_ setEnabled:have_new_config_];
   [pin_ setEnabled:have_new_config_];
   [apply_button_ setEnabled:(is_pane_unlocked_ && have_new_config_)];
 }
 
 - (void)showError {
   NSAlert* alert = [[NSAlert alloc] init];
@@ skipping 17 matching lines @@
                       contextInfo:nil];
   [alert release];
 }
 
 - (void)applyNewServiceConfig {
   [self updateServiceStatus];
   std::string serialized_config = config_->GetSerializedData();
   const char* command = is_service_running_ ? "--save-config" : "--enable";
   if (![self runHelperAsRootWithCommand:command
                               inputData:serialized_config]) {
-    LOG(ERROR) << "Failed to run the helper tool";
+    NSLog(@"Failed to run the helper tool");
     [self showError];
     return;
   }
 
   have_new_config_ = NO;
 
   // If the service is running, send a signal to cause it to reload its
   // configuration, otherwise start the service.
   if (is_service_running_) {
     pid_t job_pid = base::mac::PIDForJob(kServiceName);
     if (job_pid > 0) {
       kill(job_pid, SIGHUP);
     } else {
-      LOG(ERROR) << "Failed to obtain PID of service " << kServiceName;
+      NSLog(@"Failed to obtain PID of service " kServiceName);
       [self showError];
     }
   } else {
     [self sendJobControlMessage:LAUNCH_KEY_STARTJOB];
   }
 
   // Broadcast a distributed notification to inform the plugin that the
   // configuration has been applied.
   [self notifyPlugin: kUpdateSucceededNotificationName];
 }
 
 - (BOOL)runHelperAsRootWithCommand:(const char*)command
                          inputData:(const std::string&)input_data {
   AuthorizationRef authorization =
       [[authorization_view_ authorization] authorizationRef];
   if (!authorization) {
-    LOG(ERROR) << "Failed to obtain authorizationRef";
+    NSLog(@"Failed to obtain authorizationRef");
     return NO;
   }
 
   // TODO(lambroslambrou): Replace the deprecated ExecuteWithPrivileges
   // call with a launchd-based helper tool, which is more secure.
   // http://crbug.com/120903
   const char* arguments[] = { command, NULL };
   FILE* pipe = NULL;
   pid_t pid;
   OSStatus status = base::mac::ExecuteWithPrivilegesAndGetPID(
       authorization,
       kHelperTool,
       kAuthorizationFlagDefaults,
       arguments,
       &pipe,
       &pid);
   if (status != errAuthorizationSuccess) {
-    OSSTATUS_LOG(ERROR, status) << "AuthorizationExecuteWithPrivileges";
+    NSLog(@"AuthorizationExecuteWithPrivileges: %s (%d)",
+          GetMacOSStatusErrorString(status), static_cast<int>(status));
     return NO;
   }
   if (pid == -1) {
-    LOG(ERROR) << "Failed to get child PID";
+    NSLog(@"Failed to get child PID");
     if (pipe)
       fclose(pipe);
 
     return NO;
   }
   if (!pipe) {
-    LOG(ERROR) << "Unexpected NULL pipe";
+    NSLog(@"Unexpected NULL pipe");
     return NO;
   }
 
   // Some cleanup is needed (closing the pipe and waiting for the child
   // process), so flag any errors before returning.
   BOOL error = NO;
 
   if (!input_data.empty()) {
     size_t bytes_written = fwrite(input_data.data(), sizeof(char),
                                   input_data.size(), pipe);
     // According to the fwrite manpage, a partial count is returned only if a
     // write error has occurred.
     if (bytes_written != input_data.size()) {
-      LOG(ERROR) << "Failed to write data to child process";
+      NSLog(@"Failed to write data to child process");
       error = YES;
     }
   }
 
   // In all cases, fclose() should be called with the returned FILE*.  In the
   // case of sending data to the child, this needs to be done before calling
   // waitpid(), since the child reads until EOF on its stdin, so calling
   // waitpid() first would result in deadlock.
   if (fclose(pipe) != 0) {
-    PLOG(ERROR) << "fclose";
+    NSLog(@"fclose failed with error %d", errno);
     error = YES;
   }
 
   int exit_status;
   pid_t wait_result = HANDLE_EINTR(waitpid(pid, &exit_status, 0));
   if (wait_result != pid) {
-    PLOG(ERROR) << "waitpid";
+    NSLog(@"waitpid failed with error %d", errno);
     error = YES;
   }
 
   // No more cleanup needed.
   if (error)
     return NO;
 
   if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == 0) {
     return YES;
   } else {
-    LOG(ERROR) << kHelperTool << " failed with exit status " << exit_status;
+    NSLog(@"%s failed with exit status %d", kHelperTool, exit_status);
     return NO;
   }
 }
 
 - (BOOL)sendJobControlMessage:(const char*)launch_key {
   base::mac::ScopedLaunchData response(
       base::mac::MessageForJob(kServiceName, launch_key));
   if (!response) {
-    LOG(ERROR) << "Failed to send message to launchd";
+    NSLog(@"Failed to send message to launchd");
     [self showError];
     return NO;
   }
 
   // Expect a response of type LAUNCH_DATA_ERRNO.
   launch_data_type_t type = launch_data_get_type(response.get());
   if (type != LAUNCH_DATA_ERRNO) {
-    LOG(ERROR) << "launchd returned unexpected type: " << type;
+    NSLog(@"launchd returned unexpected type: %d", type);
     [self showError];
     return NO;
   }
 
   int error = launch_data_get_errno(response.get());
   if (error) {
-    LOG(ERROR) << "launchd returned error: " << error;
+    NSLog(@"launchd returned error: %d", error);
     [self showError];
     return NO;
   }
   return YES;
 }
 
 - (void)notifyPlugin:(const char*)message {
   NSDistributedNotificationCenter* center =
       [NSDistributedNotificationCenter defaultCenter];
   NSString* name = [NSString stringWithUTF8String:message];
   [center postNotificationName:name
                         object:nil
                       userInfo:nil];
 }
 
 @end