AU: Detect and report public key verify failures, but continue updating.

update_attempter.cc

 // Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "update_engine/update_attempter.h"
 
 // From 'man clock_gettime': feature test macro: _POSIX_C_SOURCE >= 199309L
 #ifndef _POSIX_C_SOURCE
 #define _POSIX_C_SOURCE 199309L
 #endif  // _POSIX_C_SOURCE
@@ skipping 14 matching lines @@
 #include "update_engine/multi_range_http_fetcher.h"
 #include "update_engine/omaha_request_action.h"
 #include "update_engine/omaha_request_params.h"
 #include "update_engine/omaha_response_handler_action.h"
 #include "update_engine/postinstall_runner_action.h"
 #include "update_engine/prefs_interface.h"
 #include "update_engine/update_check_scheduler.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
+using google::protobuf::NewPermanentCallback;
 using std::make_pair;
 using std::tr1::shared_ptr;
 using std::string;
 using std::vector;
 
 namespace chromeos_update_engine {
 
 const int UpdateAttempter::kMaxDeltaUpdateFailures = 3;
 
 const char* kUpdateCompletedMarker =
@@ skipping 136 matching lines @@
       new FilesystemCopierAction(true, false));
   shared_ptr<OmahaRequestAction> download_started_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadStarted),
                              new LibcurlHttpFetcher(GetProxyResolver())));
   shared_ptr<DownloadAction> download_action(
       new DownloadAction(prefs_, new MultiRangeHTTPFetcher(
           new LibcurlHttpFetcher(GetProxyResolver()))));
+  // This action is always initiall in place to warn of a signature failure.

[gauravsh, 2011/04/06 00:07:23]

nit: "initiall"?

+  // If it's not needed, it will be told to skip.
+  shared_ptr<OmahaRequestAction> download_signature_warning(
+      new OmahaRequestAction(
+          prefs_,
+          omaha_request_params_,
+          new OmahaEvent(
+              OmahaEvent::kTypeUpdateDownloadFinished,
+              OmahaEvent::kResultError,
+              kActionCodeDownloadPayloadPubKeyVerificationError),
+          new LibcurlHttpFetcher(GetProxyResolver())));
+  download_action->set_skip_reporting_signature_fail(
+      NewPermanentCallback(download_signature_warning.get(),
+                           &OmahaRequestAction::set_should_skip,
+                           true));
   shared_ptr<OmahaRequestAction> download_finished_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(
                                  OmahaEvent::kTypeUpdateDownloadFinished),
                              new LibcurlHttpFetcher(GetProxyResolver())));
   shared_ptr<FilesystemCopierAction> filesystem_verifier_action(
       new FilesystemCopierAction(false, true));
   shared_ptr<FilesystemCopierAction> kernel_filesystem_verifier_action(
       new FilesystemCopierAction(true, true));
   shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
       new PostinstallRunnerAction);
   shared_ptr<OmahaRequestAction> update_complete_action(
       new OmahaRequestAction(prefs_,
                              omaha_request_params_,
                              new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
                              new LibcurlHttpFetcher(GetProxyResolver())));
 
   download_action->set_delegate(this);
   response_handler_action_ = response_handler_action;
   download_action_ = download_action;
 
   actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
   actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
   actions_.push_back(shared_ptr<AbstractAction>(filesystem_copier_action));
   actions_.push_back(shared_ptr<AbstractAction>(
       kernel_filesystem_copier_action));
   actions_.push_back(shared_ptr<AbstractAction>(download_started_action));
   actions_.push_back(shared_ptr<AbstractAction>(download_action));
+  actions_.push_back(shared_ptr<AbstractAction>(download_signature_warning));
   actions_.push_back(shared_ptr<AbstractAction>(download_finished_action));
   actions_.push_back(shared_ptr<AbstractAction>(filesystem_verifier_action));
   actions_.push_back(shared_ptr<AbstractAction>(
       kernel_filesystem_verifier_action));
   actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action));
   actions_.push_back(shared_ptr<AbstractAction>(update_complete_action));
 
   // Enqueue the actions
   for (vector<shared_ptr<AbstractAction> >::iterator it = actions_.begin();
        it != actions_.end(); ++it) {
@@ skipping 349 matching lines @@
     uint64_t resume_offset = manifest_metadata_size + next_data_offset;
     if (resume_offset < response_handler_action_->install_plan().size) {
       fetcher->AddRange(resume_offset, -1);
     }
   } else {
     fetcher->AddRange(0, -1);
   }
 }
 
 }  // namespace chromeos_update_engine