Restructure login

mojo/shell/shell.cc

 // Copyright 2014 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 "mojo/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 21 matching lines @@
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 const char kCatalogName[] = "mojo:catalog";
 const char kShellName[] = "mojo:shell";
 const char kCapabilityClass_UserID[] = "user_id";
 const char kCapabilityClass_ClientProcess[] = "client_process";
 const char kCapabilityClass_InstanceName[] = "instance_name";
+const char kCapabilityClass_AllUsers[] = "all_users";
 
 void EmptyResolverCallback(const String& resolved_name,
                            const String& resolved_instance,
                            mojom::CapabilitySpecPtr capabilities,
                            const String& file_url) {}
 
 }
 
 Identity CreateShellIdentity() {
   return Identity(kShellName, mojom::kRootUserID);
@@ skipping 37 matching lines @@
   for (const auto& class_name : request.classes) {
     auto it = target_spec.provided.find(class_name);
     if (it != target_spec.provided.end()) {
       for (const auto& interface_name : it->second)
         request.interfaces.insert(interface_name);
     }
   }
   return request;
 }
 
+bool HasClass(const CapabilitySpec& spec, const std::string& class_name) {
+  auto it = spec.required.find(kShellName);
+  if (it == spec.required.end())
+    return false;
+  return it->second.classes.find(class_name) != it->second.classes.end();
+}
+
 // Encapsulates a connection to an instance of an application, tracked by the
 // shell's Shell.
 class Shell::Instance : public mojom::Connector,
                         public mojom::PIDReceiver,
                         public ShellClient,
                         public InterfaceFactory<mojom::Shell>,
                         public mojom::Shell {
  public:
   Instance(mojo::shell::Shell* shell,
            const Identity& identity,
@@ skipping 90 matching lines @@
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
     info->identity = mojom::Identity::From(identity_);
     info->pid = pid_;
     return info;
   }
 
+  const CapabilitySpec& capability_spec() const {
+    return capability_spec_;
+  }
   const Identity& identity() const { return identity_; }
   uint32_t id() const { return id_; }
 
   // ShellClient:
   bool AcceptConnection(Connection* connection) override {
     connection->AddInterface<mojom::Shell>(this);
     return true;
   }
 
  private:
@@ skipping 63 matching lines @@
       return false;
     }
     return true;
   }
 
   bool ValidateClientProcessConnection(
       mojom::ClientProcessConnectionPtr* client_process_connection,
       const Identity& target,
       const ConnectCallback& callback) {
     if (!client_process_connection->is_null()) {
-      if (!HasClass(kCapabilityClass_ClientProcess)) {
+      if (!HasClass(capability_spec_, kCapabilityClass_ClientProcess)) {
         LOG(ERROR) << "Error: Instance: " << identity_.name() << " attempting "
                    << "to register an instance for a process it created for "
                    << "target: " << target.name() << " without the "
                    << "mojo:shell{client_process} capability class.";
         callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                      mojom::kInheritUserID, mojom::kInvalidInstanceID);
         return false;
       }
 
       if (!(*client_process_connection)->shell_client.is_valid() ||
@@ skipping 17 matching lines @@
     return true;
   }
 
   bool ValidateCapabilities(const Identity& target,
                             const ConnectCallback& callback) {
     // TODO(beng): Need to do the following additional policy validation of
     // whether this instance is allowed to connect using:
     // - a non-null client_process_connection.
     if (target.user_id() != identity_.user_id() &&
         target.user_id() != mojom::kRootUserID &&
-        !HasClass(kCapabilityClass_UserID)) {
+        !HasClass(capability_spec_, kCapabilityClass_UserID)) {
       LOG(ERROR) << "Instance: " << identity_.name() << " running as: "
                   << identity_.user_id() << " attempting to connect to: "
                   << target.name() << " as: " << target.user_id() << " without "
                   << " the mojo:shell{user_id} capability class.";
       callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                    mojom::kInheritUserID, mojom::kInvalidInstanceID);
       return false;
     }
     if (!target.instance().empty() &&
         target.instance() != GetNamePath(target.name()) &&
-        !HasClass(kCapabilityClass_InstanceName)) {
+        !HasClass(capability_spec_, kCapabilityClass_InstanceName)) {
       LOG(ERROR) << "Instance: " << identity_.name() << " attempting to "
                   << "connect to " << target.name() << " using Instance name: "
                   << target.instance() << " without the "
                   << "mojo:shell{instance_name} capability class.";
       callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                    mojom::kInheritUserID, mojom::kInvalidInstanceID);
       return false;
 
     }
 
     if (allow_any_application_ ||
         capability_spec_.required.find(target.name()) !=
             capability_spec_.required.end()) {
       return true;
     }
     LOG(ERROR) << "Capabilities prevented connection from: " <<
                   identity_.name() << " to: " << target.name();
     callback.Run(mojom::ConnectResult::ACCESS_DENIED,
                  mojom::kInheritUserID, mojom::kInvalidInstanceID);
     return false;
   }
 
-  bool HasClass(const std::string& class_name) const {
-    auto it = capability_spec_.required.find(kShellName);
-    if (it == capability_spec_.required.end())
-      return false;
-    return it->second.classes.find(class_name) != it->second.classes.end();
-  }
-
   uint32_t GenerateUniqueID() const {
     static uint32_t id = mojom::kInvalidInstanceID;
     ++id;
     CHECK_NE(mojom::kInvalidInstanceID, id);
     return id;
   }
 
   void PIDAvailable(base::ProcessId pid) {
     pid_ = pid;
     shell_->NotifyPIDAvailable(id_, pid_);
@@ skipping 175 matching lines @@
 
 Shell::Instance* Shell::GetExistingInstance(const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   return it != identity_to_instance_.end() ? it->second : nullptr;
 }
 
 Shell::Instance* Shell::GetExistingOrRootInstance(
     const Identity& identity) const {
   Instance* instance = GetExistingInstance(identity);
   if (!instance) {
+    if (singletons_.find(identity.name()) != singletons_.end()) {
+      for (auto entry : identity_to_instance_) {
+        if (entry.first.name() == identity.name() &&
+            entry.first.instance() == identity.instance()) {
+          return entry.second;
+        }
+      }
+    }
+
     Identity root_identity = identity;
     root_identity.set_user_id(mojom::kRootUserID);
     instance = GetExistingInstance(root_identity);
   }
   return instance;
 }
 
 void Shell::NotifyPIDAvailable(uint32_t id, base::ProcessId pid) {
   instance_listeners_.ForAllPtrs([id, pid](mojom::InstanceListener* listener) {
                                    listener->InstancePIDAvailable(id, pid);
@@ skipping 89 matching lines @@
   if (ConnectToExistingInstance(&params))
     return;
 
   Identity source = params->source();
   // |capabilities_ptr| can be null when there is no manifest, e.g. for URL
   // types not resolvable by the resolver.
   CapabilitySpec capabilities = GetPermissiveCapabilities();
   if (!capabilities_ptr.is_null())
     capabilities = capabilities_ptr.To<CapabilitySpec>();
 
+  // Clients that request "all_users" class from the shell are allowed to
+  // field connection requests from any user.
+  if (HasClass(capabilities, kCapabilityClass_AllUsers))
+    singletons_.insert(target.name());
+
   mojom::ClientProcessConnectionPtr client_process_connection =
       params->TakeClientProcessConnection();
   Instance* instance = CreateInstance(target, capabilities);
 
   // Below are various paths through which a new Instance can be bound to a
   // ShellClient proxy.
   if (client.is_bound()) {
     // If a ShellClientPtr was provided, there's no more work to do: someone
     // is already holding a corresponding ShellClientRequest.
     instance->StartWithClient(std::move(client));
@@ skipping 45 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo