Fix races when the same bits are downloaded from 2 URLs.

shell/application_manager/network_fetcher.cc

 // Copyright 2015 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.
 
 #include "shell/application_manager/network_fetcher.h"
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "shell/application_manager/data_pipe_peek.h"
+#include "shell/switches.h"
 
 namespace mojo {
 namespace shell {
 
 NetworkFetcher::NetworkFetcher(bool disable_cache,
                                const GURL& url,
                                NetworkService* network_service,
                                const FetchCallback& loader_callback)
     : Fetcher(loader_callback),
       disable_cache_(false),
@@ skipping 45 matching lines @@
   // TODO(eseidel): Paths or URLs with spaces will need quoting.
   std::string map_entry =
       base::StringPrintf("%s %s\n", path.value().c_str(), url.spec().c_str());
   // TODO(eseidel): AppendToFile is missing O_CREAT, crbug.com/450696
   if (!PathExists(map_path))
     base::WriteFile(map_path, map_entry.data(), map_entry.length());
   else
     base::AppendToFile(map_path, map_entry.data(), map_entry.length());
 }
 
-// AppIds should be be both predictable and unique, but any hash would work.
-// Currently we use sha256 from crypto/secure_hash.h
+// For remote debugging, GDB needs to be, a apriori, aware of the filename a
+// library will be loaded from. AppIds should be be both predictable and unique,
+// but any hash would work. Currently we use sha256 from crypto/secure_hash.h
 bool NetworkFetcher::ComputeAppId(const base::FilePath& path,
                                   std::string* digest_string) {
   scoped_ptr<crypto::SecureHash> ctx(
       crypto::SecureHash::Create(crypto::SecureHash::SHA256));
   base::File file(path, base::File::FLAG_OPEN | base::File::FLAG_READ);
   if (!file.IsValid()) {
     LOG(ERROR) << "Failed to open " << path.value() << " for computing AppId";
     return false;
   }
   char buf[1024];
   while (file.IsValid()) {
     int bytes_read = file.ReadAtCurrentPos(buf, sizeof(buf));
     if (bytes_read == 0)
       break;
     ctx->Update(buf, bytes_read);
   }
   if (!file.IsValid()) {
     LOG(ERROR) << "Error reading " << path.value();
     return false;
   }
   // The output is really a vector of unit8, we're cheating by using a string.
   std::string output(crypto::kSHA256Length, 0);
   ctx->Finish(string_as_array(&output), output.size());
   output = base::HexEncode(output.c_str(), output.size());
   // Using lowercase for compatiblity with sha256sum output.
   *digest_string = base::StringToLowerASCII(output);
   return true;
 }
 
-bool NetworkFetcher::RenameToAppId(const base::FilePath& old_path,
+bool NetworkFetcher::RenameToAppId(const GURL& url,
+                                   const base::FilePath& old_path,
                                    base::FilePath* new_path) {
   std::string app_id;
   if (!ComputeAppId(old_path, &app_id))
     return false;
 
+  // Using a hash of the url as a directory to prevent a race when the same
+  // bytes are downloaded from 2 different urls. In particular, if the same
+  // application is connected to twice concurrently with different query
+  // parameters, the directory will be different, which will prevent the
+  // collision.
+  std::string dirname = base::HexEncode(
+      crypto::SHA256HashString(url.spec()).data(), crypto::kSHA256Length);
+
   base::FilePath temp_dir;
   base::GetTempDir(&temp_dir);
+  base::FilePath app_dir = temp_dir.Append(dirname);
+  // The directory is leaked, because it can be reused at any time if the same
+  // application is downloaded. Deleting it would be racy. This is only
+  // happening when --predictable-app-filenames is used.
+  bool result = base::CreateDirectoryAndGetError(app_dir, nullptr);
+  DCHECK(result);
   std::string unique_name = base::StringPrintf("%s.mojo", app_id.c_str());
-  *new_path = temp_dir.Append(unique_name);
+  *new_path = app_dir.Append(unique_name);
   return base::Move(old_path, *new_path);
 }
 
 void NetworkFetcher::CopyCompleted(
     base::Callback<void(const base::FilePath&, bool)> callback,
     bool success) {
-  // The copy completed, now move to $TMP/$APP_ID.mojo before the dlopen.
   if (success) {
-    success = false;
-    base::FilePath new_path;
-    if (RenameToAppId(path_, &new_path)) {
-      if (base::PathExists(new_path)) {
-        path_ = new_path;
-        success = true;
-        RecordCacheToURLMapping(path_, url_);
+    if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kPredictableAppFilenames)) {
+      // The copy completed, now move to $TMP/$APP_ID.mojo before the dlopen.
+      success = false;
+      base::FilePath new_path;
+      if (RenameToAppId(url_, path_, &new_path)) {
+        if (base::PathExists(new_path)) {
+          path_ = new_path;
+          success = true;
+        }
       }
     }
   }
 
+  if (success)
+    RecordCacheToURLMapping(path_, url_);
+
   base::MessageLoop::current()->PostTask(FROM_HERE,
                                          base::Bind(callback, path_, success));
 }
 
 void NetworkFetcher::AsPath(
     base::TaskRunner* task_runner,
     base::Callback<void(const base::FilePath&, bool)> callback) {
   if (!path_.empty() || !response_) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, path_, base::PathExists(path_)));
@@ skipping 51 matching lines @@
     loader_callback_.Run(make_scoped_ptr<Fetcher>(NULL));
     return;
   }
 
   response_ = response.Pass();
   loader_callback_.Run(make_scoped_ptr(this));
 }
 
 }  // namespace shell
 }  // namespace mojo