me2me_preference_pane.mm revision 68043e1e95eeb07d5cae7aca370b26518b0867d6
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#import "remoting/host/mac/me2me_preference_pane.h"
6
7#import <Cocoa/Cocoa.h>
8#include <CommonCrypto/CommonHMAC.h>
9#include <errno.h>
10#include <launch.h>
11#import <PreferencePanes/PreferencePanes.h>
12#import <SecurityInterface/SFAuthorizationView.h>
13#include <stdlib.h>
14#include <unistd.h>
15
16#include <fstream>
17
18#include "base/mac/scoped_launch_data.h"
19#include "base/memory/scoped_ptr.h"
20#include "base/posix/eintr_wrapper.h"
21#include "remoting/host/constants_mac.h"
22#include "remoting/host/host_config.h"
23#import "remoting/host/mac/me2me_preference_pane_confirm_pin.h"
24#import "remoting/host/mac/me2me_preference_pane_disable.h"
25#include "third_party/jsoncpp/source/include/json/reader.h"
26#include "third_party/jsoncpp/source/include/json/writer.h"
27#include "third_party/modp_b64/modp_b64.h"
28
29namespace {
30
31bool GetTemporaryConfigFilePath(std::string* path) {
32  NSString* filename = NSTemporaryDirectory();
33  if (filename == nil)
34    return false;
35
36  *path = [[NSString stringWithFormat:@"%@/%s",
37            filename, remoting::kHostConfigFileName] UTF8String];
38  return true;
39}
40
41bool IsConfigValid(const remoting::JsonHostConfig* config) {
42  std::string value;
43  return (config->GetString(remoting::kHostIdConfigPath, &value) &&
44          config->GetString(remoting::kHostSecretHashConfigPath, &value) &&
45          config->GetString(remoting::kXmppLoginConfigPath, &value));
46}
47
48bool IsPinValid(const std::string& pin, const std::string& host_id,
49                const std::string& host_secret_hash) {
50  // TODO(lambroslambrou): Once the "base" target supports building for 64-bit
51  // on Mac OS X, remove this code and replace it with |VerifyHostPinHash()|
52  // from host/pin_hash.h.
53  size_t separator = host_secret_hash.find(':');
54  if (separator == std::string::npos)
55    return false;
56
57  std::string method = host_secret_hash.substr(0, separator);
58  if (method != "hmac") {
59    NSLog(@"Authentication method '%s' not supported", method.c_str());
60    return false;
61  }
62
63  std::string hash_base64 = host_secret_hash.substr(separator + 1);
64
65  // Convert |hash_base64| to |hash|, based on code from base/base64.cc.
66  int hash_base64_size = static_cast<int>(hash_base64.size());
67  std::string hash;
68  hash.resize(modp_b64_decode_len(hash_base64_size));
69
70  // modp_b64_decode_len() returns at least 1, so hash[0] is safe here.
71  int hash_size = modp_b64_decode(&(hash[0]), hash_base64.data(),
72                                  hash_base64_size);
73  if (hash_size < 0) {
74    NSLog(@"Failed to parse host_secret_hash");
75    return false;
76  }
77  hash.resize(hash_size);
78
79  std::string computed_hash;
80  computed_hash.resize(CC_SHA256_DIGEST_LENGTH);
81
82  CCHmac(kCCHmacAlgSHA256,
83         host_id.data(), host_id.size(),
84         pin.data(), pin.size(),
85         &(computed_hash[0]));
86
87  // Normally, a constant-time comparison function would be used, but it is
88  // unnecessary here as the "secret" is already readable by the user
89  // supplying input to this routine.
90  return computed_hash == hash;
91}
92
93}  // namespace
94
95// These methods are copied from base/mac, but with the logging changed to use
96// NSLog().
97//
98// TODO(lambroslambrou): Once the "base" target supports building for 64-bit
99// on Mac OS X, remove these implementations and use the ones in base/mac.
100namespace base {
101namespace mac {
102
103// MessageForJob sends a single message to launchd with a simple dictionary
104// mapping |operation| to |job_label|, and returns the result of calling
105// launch_msg to send that message. On failure, returns NULL. The caller
106// assumes ownership of the returned launch_data_t object.
107launch_data_t MessageForJob(const std::string& job_label,
108                            const char* operation) {
109  // launch_data_alloc returns something that needs to be freed.
110  ScopedLaunchData message(launch_data_alloc(LAUNCH_DATA_DICTIONARY));
111  if (!message) {
112    NSLog(@"launch_data_alloc");
113    return NULL;
114  }
115
116  // launch_data_new_string returns something that needs to be freed, but
117  // the dictionary will assume ownership when launch_data_dict_insert is
118  // called, so put it in a scoper and .release() it when given to the
119  // dictionary.
120  ScopedLaunchData job_label_launchd(launch_data_new_string(job_label.c_str()));
121  if (!job_label_launchd) {
122    NSLog(@"launch_data_new_string");
123    return NULL;
124  }
125
126  if (!launch_data_dict_insert(message,
127                               job_label_launchd.release(),
128                               operation)) {
129    return NULL;
130  }
131
132  return launch_msg(message);
133}
134
135pid_t PIDForJob(const std::string& job_label) {
136  ScopedLaunchData response(MessageForJob(job_label, LAUNCH_KEY_GETJOB));
137  if (!response) {
138    return -1;
139  }
140
141  launch_data_type_t response_type = launch_data_get_type(response);
142  if (response_type != LAUNCH_DATA_DICTIONARY) {
143    if (response_type == LAUNCH_DATA_ERRNO) {
144      NSLog(@"PIDForJob: error %d", launch_data_get_errno(response));
145    } else {
146      NSLog(@"PIDForJob: expected dictionary, got %d", response_type);
147    }
148    return -1;
149  }
150
151  launch_data_t pid_data = launch_data_dict_lookup(response,
152                                                   LAUNCH_JOBKEY_PID);
153  if (!pid_data)
154    return 0;
155
156  if (launch_data_get_type(pid_data) != LAUNCH_DATA_INTEGER) {
157    NSLog(@"PIDForJob: expected integer");
158    return -1;
159  }
160
161  return launch_data_get_integer(pid_data);
162}
163
164OSStatus ExecuteWithPrivilegesAndGetPID(AuthorizationRef authorization,
165                                        const char* tool_path,
166                                        AuthorizationFlags options,
167                                        const char** arguments,
168                                        FILE** pipe,
169                                        pid_t* pid) {
170  // pipe may be NULL, but this function needs one.  In that case, use a local
171  // pipe.
172  FILE* local_pipe;
173  FILE** pipe_pointer;
174  if (pipe) {
175    pipe_pointer = pipe;
176  } else {
177    pipe_pointer = &local_pipe;
178  }
179
180  // AuthorizationExecuteWithPrivileges wants |char* const*| for |arguments|,
181  // but it doesn't actually modify the arguments, and that type is kind of
182  // silly and callers probably aren't dealing with that.  Put the cast here
183  // to make things a little easier on callers.
184  OSStatus status = AuthorizationExecuteWithPrivileges(authorization,
185                                                       tool_path,
186                                                       options,
187                                                       (char* const*)arguments,
188                                                       pipe_pointer);
189  if (status != errAuthorizationSuccess) {
190    return status;
191  }
192
193  long line_pid = -1;
194  size_t line_length = 0;
195  char* line_c = fgetln(*pipe_pointer, &line_length);
196  if (line_c) {
197    if (line_length > 0 && line_c[line_length - 1] == '\n') {
198      // line_c + line_length is the start of the next line if there is one.
199      // Back up one character.
200      --line_length;
201    }
202    std::string line(line_c, line_length);
203
204    // The version in base/mac used base::StringToInt() here.
205    line_pid = strtol(line.c_str(), NULL, 10);
206    if (line_pid == 0) {
207      NSLog(@"ExecuteWithPrivilegesAndGetPid: funny line: %s", line.c_str());
208      line_pid = -1;
209    }
210  } else {
211    NSLog(@"ExecuteWithPrivilegesAndGetPid: no line");
212  }
213
214  if (!pipe) {
215    fclose(*pipe_pointer);
216  }
217
218  if (pid) {
219    *pid = line_pid;
220  }
221
222  return status;
223}
224
225}  // namespace mac
226}  // namespace base
227
228namespace remoting {
229
230JsonHostConfig::JsonHostConfig(const std::string& filename)
231    : filename_(filename) {
232}
233
234JsonHostConfig::~JsonHostConfig() {
235}
236
237bool JsonHostConfig::Read() {
238  std::ifstream file(filename_.c_str());
239  Json::Reader reader;
240  return reader.parse(file, config_, false /* ignore comments */);
241}
242
243bool JsonHostConfig::GetString(const std::string& path,
244                               std::string* out_value) const {
245  if (!config_.isObject())
246    return false;
247
248  if (!config_.isMember(path))
249    return false;
250
251  Json::Value value = config_[path];
252  if (!value.isString())
253    return false;
254
255  *out_value = value.asString();
256  return true;
257}
258
259std::string JsonHostConfig::GetSerializedData() const {
260  Json::FastWriter writer;
261  return writer.write(config_);
262}
263
264}  // namespace remoting
265
266@implementation Me2MePreferencePane
267
268- (void)mainViewDidLoad {
269  [authorization_view_ setDelegate:self];
270  [authorization_view_ setString:kAuthorizationRightExecute];
271  [authorization_view_ setAutoupdate:YES
272                            interval:60];
273  confirm_pin_view_ = [[Me2MePreferencePaneConfirmPin alloc] init];
274  [confirm_pin_view_ setDelegate:self];
275  disable_view_ = [[Me2MePreferencePaneDisable alloc] init];
276  [disable_view_ setDelegate:self];
277}
278
279- (void)willSelect {
280  have_new_config_ = NO;
281  awaiting_service_stop_ = NO;
282
283  NSDistributedNotificationCenter* center =
284      [NSDistributedNotificationCenter defaultCenter];
285  [center addObserver:self
286             selector:@selector(onNewConfigFile:)
287                 name:[NSString stringWithUTF8String:remoting::kServiceName]
288               object:nil];
289
290  service_status_timer_ =
291      [[NSTimer scheduledTimerWithTimeInterval:2.0
292                                        target:self
293                                      selector:@selector(refreshServiceStatus:)
294                                      userInfo:nil
295                                       repeats:YES] retain];
296  [self updateServiceStatus];
297  [self updateAuthorizationStatus];
298
299  [self checkInstalledVersion];
300  if (!restart_pending_or_canceled_)
301    [self readNewConfig];
302
303  [self updateUI];
304}
305
306- (void)didSelect {
307  [self checkInstalledVersion];
308}
309
310- (void)willUnselect {
311  NSDistributedNotificationCenter* center =
312      [NSDistributedNotificationCenter defaultCenter];
313  [center removeObserver:self];
314
315  [service_status_timer_ invalidate];
316  [service_status_timer_ release];
317  service_status_timer_ = nil;
318
319  [self notifyPlugin:UPDATE_FAILED_NOTIFICATION_NAME];
320}
321
322- (void)applyConfiguration:(id)sender
323                       pin:(NSString*)pin {
324  if (!have_new_config_) {
325    // It shouldn't be possible to hit the button if there is no config to
326    // apply, but check anyway just in case it happens somehow.
327    return;
328  }
329
330  // Ensure the authorization token is up-to-date before using it.
331  [self updateAuthorizationStatus];
332  [self updateUI];
333
334  std::string pin_utf8 = [pin UTF8String];
335  std::string host_id, host_secret_hash;
336  bool result = (config_->GetString(remoting::kHostIdConfigPath, &host_id) &&
337                 config_->GetString(remoting::kHostSecretHashConfigPath,
338                                    &host_secret_hash));
339  if (!result) {
340    [self showError];
341    return;
342  }
343  if (!IsPinValid(pin_utf8, host_id, host_secret_hash)) {
344    [self showIncorrectPinMessage];
345    return;
346  }
347
348  [self applyNewServiceConfig];
349  [self updateUI];
350}
351
352- (void)onDisable:(id)sender {
353  // Ensure the authorization token is up-to-date before using it.
354  [self updateAuthorizationStatus];
355  [self updateUI];
356  if (!is_pane_unlocked_)
357    return;
358
359  if (![self runHelperAsRootWithCommand:"--disable"
360                              inputData:""]) {
361    NSLog(@"Failed to run the helper tool");
362    [self showError];
363    [self notifyPlugin:UPDATE_FAILED_NOTIFICATION_NAME];
364    return;
365  }
366
367  // Stop the launchd job.  This cannot easily be done by the helper tool,
368  // since the launchd job runs in the current user's context.
369  [self sendJobControlMessage:LAUNCH_KEY_STOPJOB];
370  awaiting_service_stop_ = YES;
371}
372
373- (void)onNewConfigFile:(NSNotification*)notification {
374  [self checkInstalledVersion];
375  if (!restart_pending_or_canceled_)
376    [self readNewConfig];
377
378  [self updateUI];
379}
380
381- (void)refreshServiceStatus:(NSTimer*)timer {
382  BOOL was_running = is_service_running_;
383  [self updateServiceStatus];
384  if (awaiting_service_stop_ && !is_service_running_) {
385    awaiting_service_stop_ = NO;
386    [self notifyPlugin:UPDATE_SUCCEEDED_NOTIFICATION_NAME];
387  }
388
389  if (was_running != is_service_running_)
390    [self updateUI];
391}
392
393- (void)authorizationViewDidAuthorize:(SFAuthorizationView*)view {
394  [self updateAuthorizationStatus];
395  [self updateUI];
396}
397
398- (void)authorizationViewDidDeauthorize:(SFAuthorizationView*)view {
399  [self updateAuthorizationStatus];
400  [self updateUI];
401}
402
403- (void)updateServiceStatus {
404  pid_t job_pid = base::mac::PIDForJob(remoting::kServiceName);
405  is_service_running_ = (job_pid > 0);
406}
407
408- (void)updateAuthorizationStatus {
409  is_pane_unlocked_ = [authorization_view_ updateStatus:authorization_view_];
410}
411
412- (void)readNewConfig {
413  std::string file;
414  if (!GetTemporaryConfigFilePath(&file)) {
415    NSLog(@"Failed to get path of configuration data.");
416    [self showError];
417    return;
418  }
419  if (access(file.c_str(), F_OK) != 0)
420    return;
421
422  scoped_ptr<remoting::JsonHostConfig> new_config_(
423      new remoting::JsonHostConfig(file));
424  if (!new_config_->Read()) {
425    // Report the error, because the file exists but couldn't be read.  The
426    // case of non-existence is normal and expected.
427    NSLog(@"Error reading configuration data from %s", file.c_str());
428    [self showError];
429    return;
430  }
431  remove(file.c_str());
432  if (!IsConfigValid(new_config_.get())) {
433    NSLog(@"Invalid configuration data read.");
434    [self showError];
435    return;
436  }
437
438  config_.swap(new_config_);
439  have_new_config_ = YES;
440
441  [confirm_pin_view_ resetPin];
442}
443
444- (void)updateUI {
445  if (have_new_config_) {
446    [box_ setContentView:[confirm_pin_view_ view]];
447  } else {
448    [box_ setContentView:[disable_view_ view]];
449  }
450
451  // TODO(lambroslambrou): Show "enabled" and "disabled" in bold font.
452  NSString* message;
453  if (is_service_running_) {
454    if (have_new_config_) {
455      message = @"Please confirm your new PIN.";
456    } else {
457      message = @"Remote connections to this computer are enabled.";
458    }
459  } else {
460    if (have_new_config_) {
461      message = @"Remote connections to this computer are disabled. To enable "
462          "remote connections you must confirm your PIN.";
463    } else {
464      message = @"Remote connections to this computer are disabled.";
465    }
466  }
467  [status_message_ setStringValue:message];
468
469  std::string email;
470  if (config_.get()) {
471    bool result = config_->GetString(remoting::kHostOwnerConfigPath, &email);
472    if (!result) {
473      result = config_->GetString(remoting::kXmppLoginConfigPath, &email);
474
475      // The config has already been checked by |IsConfigValid|.
476      if (!result) {
477        [self showError];
478        return;
479      }
480    }
481  }
482  [disable_view_ setEnabled:(is_pane_unlocked_ && is_service_running_ &&
483                             !restart_pending_or_canceled_)];
484  [confirm_pin_view_ setEnabled:(is_pane_unlocked_ &&
485                                 !restart_pending_or_canceled_)];
486  [confirm_pin_view_ setEmail:[NSString stringWithUTF8String:email.c_str()]];
487  NSString* applyButtonText = is_service_running_ ? @"Confirm" : @"Enable";
488  [confirm_pin_view_ setButtonText:applyButtonText];
489
490  if (restart_pending_or_canceled_)
491    [authorization_view_ setEnabled:NO];
492}
493
494- (void)showError {
495  NSAlert* alert = [[NSAlert alloc] init];
496  [alert setMessageText:@"An unexpected error occurred."];
497  [alert setInformativeText:@"Check the system log for more information."];
498  [alert setAlertStyle:NSWarningAlertStyle];
499  [alert beginSheetModalForWindow:[[self mainView] window]
500                    modalDelegate:nil
501                   didEndSelector:nil
502                      contextInfo:nil];
503  [alert release];
504}
505
506- (void)showIncorrectPinMessage {
507  NSAlert* alert = [[NSAlert alloc] init];
508  [alert setMessageText:@"Incorrect PIN entered."];
509  [alert setAlertStyle:NSWarningAlertStyle];
510  [alert beginSheetModalForWindow:[[self mainView] window]
511                    modalDelegate:nil
512                   didEndSelector:nil
513                      contextInfo:nil];
514  [alert release];
515}
516
517- (void)applyNewServiceConfig {
518  [self updateServiceStatus];
519  std::string serialized_config = config_->GetSerializedData();
520  const char* command = is_service_running_ ? "--save-config" : "--enable";
521  if (![self runHelperAsRootWithCommand:command
522                              inputData:serialized_config]) {
523    NSLog(@"Failed to run the helper tool");
524    [self showError];
525    return;
526  }
527
528  have_new_config_ = NO;
529
530  // Ensure the service is started.
531  if (!is_service_running_) {
532    [self sendJobControlMessage:LAUNCH_KEY_STARTJOB];
533  }
534
535  // Broadcast a distributed notification to inform the plugin that the
536  // configuration has been applied.
537  [self notifyPlugin:UPDATE_SUCCEEDED_NOTIFICATION_NAME];
538}
539
540- (BOOL)runHelperAsRootWithCommand:(const char*)command
541                         inputData:(const std::string&)input_data {
542  AuthorizationRef authorization =
543      [[authorization_view_ authorization] authorizationRef];
544  if (!authorization) {
545    NSLog(@"Failed to obtain authorizationRef");
546    return NO;
547  }
548
549  // TODO(lambroslambrou): Replace the deprecated ExecuteWithPrivileges
550  // call with a launchd-based helper tool, which is more secure.
551  // http://crbug.com/120903
552  const char* arguments[] = { command, NULL };
553  FILE* pipe = NULL;
554  pid_t pid;
555  OSStatus status = base::mac::ExecuteWithPrivilegesAndGetPID(
556      authorization,
557      remoting::kHostHelperScriptPath,
558      kAuthorizationFlagDefaults,
559      arguments,
560      &pipe,
561      &pid);
562  if (status != errAuthorizationSuccess) {
563    NSLog(@"AuthorizationExecuteWithPrivileges: %s (%d)",
564          GetMacOSStatusErrorString(status), static_cast<int>(status));
565    return NO;
566  }
567  if (pid == -1) {
568    NSLog(@"Failed to get child PID");
569    if (pipe)
570      fclose(pipe);
571
572    return NO;
573  }
574  if (!pipe) {
575    NSLog(@"Unexpected NULL pipe");
576    return NO;
577  }
578
579  // Some cleanup is needed (closing the pipe and waiting for the child
580  // process), so flag any errors before returning.
581  BOOL error = NO;
582
583  if (!input_data.empty()) {
584    size_t bytes_written = fwrite(input_data.data(), sizeof(char),
585                                  input_data.size(), pipe);
586    // According to the fwrite manpage, a partial count is returned only if a
587    // write error has occurred.
588    if (bytes_written != input_data.size()) {
589      NSLog(@"Failed to write data to child process");
590      error = YES;
591    }
592  }
593
594  // In all cases, fclose() should be called with the returned FILE*.  In the
595  // case of sending data to the child, this needs to be done before calling
596  // waitpid(), since the child reads until EOF on its stdin, so calling
597  // waitpid() first would result in deadlock.
598  if (fclose(pipe) != 0) {
599    NSLog(@"fclose failed with error %d", errno);
600    error = YES;
601  }
602
603  int exit_status;
604  pid_t wait_result = HANDLE_EINTR(waitpid(pid, &exit_status, 0));
605  if (wait_result != pid) {
606    NSLog(@"waitpid failed with error %d", errno);
607    error = YES;
608  }
609
610  // No more cleanup needed.
611  if (error)
612    return NO;
613
614  if (WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == 0) {
615    return YES;
616  } else {
617    NSLog(@"%s failed with exit status %d", remoting::kHostHelperScriptPath,
618          exit_status);
619    return NO;
620  }
621}
622
623- (BOOL)sendJobControlMessage:(const char*)launch_key {
624  base::mac::ScopedLaunchData response(
625      base::mac::MessageForJob(remoting::kServiceName, launch_key));
626  if (!response) {
627    NSLog(@"Failed to send message to launchd");
628    [self showError];
629    return NO;
630  }
631
632  // Expect a response of type LAUNCH_DATA_ERRNO.
633  launch_data_type_t type = launch_data_get_type(response.get());
634  if (type != LAUNCH_DATA_ERRNO) {
635    NSLog(@"launchd returned unexpected type: %d", type);
636    [self showError];
637    return NO;
638  }
639
640  int error = launch_data_get_errno(response.get());
641  if (error) {
642    NSLog(@"launchd returned error: %d", error);
643    [self showError];
644    return NO;
645  }
646  return YES;
647}
648
649- (void)notifyPlugin:(const char*)message {
650  NSDistributedNotificationCenter* center =
651      [NSDistributedNotificationCenter defaultCenter];
652  NSString* name = [NSString stringWithUTF8String:message];
653  [center postNotificationName:name
654                        object:nil
655                      userInfo:nil];
656}
657
658- (void)checkInstalledVersion {
659  // There's no point repeating the check if the pane has already been disabled
660  // from a previous call to this method.  The pane only gets disabled when a
661  // version-mismatch has been detected here, so skip the check, but continue to
662  // handle the version-mismatch case.
663  if (!restart_pending_or_canceled_) {
664    NSBundle* this_bundle = [NSBundle bundleForClass:[self class]];
665    NSDictionary* this_plist = [this_bundle infoDictionary];
666    NSString* this_version = [this_plist objectForKey:@"CFBundleVersion"];
667
668    NSString* bundle_path = [this_bundle bundlePath];
669    NSString* plist_path =
670        [bundle_path stringByAppendingString:@"/Contents/Info.plist"];
671    NSDictionary* disk_plist =
672        [NSDictionary dictionaryWithContentsOfFile:plist_path];
673    NSString* disk_version = [disk_plist objectForKey:@"CFBundleVersion"];
674
675    if (disk_version == nil) {
676      NSLog(@"Failed to get installed version information");
677      [self showError];
678      return;
679    }
680
681    if ([this_version isEqualToString:disk_version])
682      return;
683
684    restart_pending_or_canceled_ = YES;
685    [self updateUI];
686  }
687
688  NSWindow* window = [[self mainView] window];
689  if (window == nil) {
690    // Defer the alert until |didSelect| is called, which happens just after
691    // the window is created.
692    return;
693  }
694
695  // This alert appears as a sheet over the top of the Chromoting pref-pane,
696  // underneath the title, so it's OK to refer to "this preference pane" rather
697  // than repeat the title "Chromoting" here.
698  NSAlert* alert = [[NSAlert alloc] init];
699  [alert setMessageText:@"System update detected"];
700  [alert setInformativeText:@"To use this preference pane, System Preferences "
701      "needs to be restarted"];
702  [alert addButtonWithTitle:@"OK"];
703  NSButton* cancel_button = [alert addButtonWithTitle:@"Cancel"];
704  [cancel_button setKeyEquivalent:@"\e"];
705  [alert setAlertStyle:NSWarningAlertStyle];
706  [alert beginSheetModalForWindow:window
707                    modalDelegate:self
708                   didEndSelector:@selector(
709                       mismatchAlertDidEnd:returnCode:contextInfo:)
710                      contextInfo:nil];
711  [alert release];
712}
713
714- (void)mismatchAlertDidEnd:(NSAlert*)alert
715                 returnCode:(NSInteger)returnCode
716                contextInfo:(void*)contextInfo {
717  if (returnCode == NSAlertFirstButtonReturn) {
718    // OK was pressed.
719
720    // Dismiss the alert window here, so that the application will respond to
721    // the NSApp terminate: message.
722    [[alert window] orderOut:nil];
723    [self restartSystemPreferences];
724  } else {
725    // Cancel was pressed.
726
727    // If there is a new config file, delete it and notify the web-app of
728    // failure to apply the config.  Otherwise, the web-app will remain in a
729    // spinning state until System Preferences eventually gets restarted and
730    // the user visits this pane again.
731    std::string file;
732    if (!GetTemporaryConfigFilePath(&file)) {
733      // There's no point in alerting the user here.  The same error would
734      // happen when the pane is eventually restarted, so the user would be
735      // alerted at that time.
736      NSLog(@"Failed to get path of configuration data.");
737      return;
738    }
739
740    remove(file.c_str());
741    [self notifyPlugin:UPDATE_FAILED_NOTIFICATION_NAME];
742  }
743}
744
745- (void)restartSystemPreferences {
746  NSTask* task = [[NSTask alloc] init];
747  NSString* command =
748      [NSString stringWithUTF8String:remoting::kHostHelperScriptPath];
749  NSArray* arguments = [NSArray arrayWithObjects:@"--relaunch-prefpane", nil];
750  [task setLaunchPath:command];
751  [task setArguments:arguments];
752  [task setStandardInput:[NSPipe pipe]];
753  [task launch];
754  [task release];
755  [NSApp terminate:nil];
756}
757
758@end
759