[NaCl SDK] nacl_io: Always create directory node in http filesystem root.

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs.cc

 // Copyright 2013 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 "nacl_io/httpfs/http_fs.h"
 
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
@@ skipping 24 matching lines @@
   for (size_t i = 0; i < s.length(); ++i) {
     char c = s[i];
     result += upper ? toupper(c) : tolower(c);
     upper = c == '-';
   }
 
   return result;
 }
 
 Error HttpFs::Access(const Path& path, int a_mode) {
-  NodeMap_t::iterator iter = node_cache_.find(path.Join());
-  if (iter == node_cache_.end()) {
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() == NULL) {
     // If we can't find the node in the cache, fetch it
     std::string url = MakeUrl(path);
-    ScopedNode node(new HttpFsNode(this, url, cache_content_));
+    node.reset(new HttpFsNode(this, url, cache_content_));
     Error error = node->Init(0);
     if (error)
       return error;
 
     error = node->GetStat(NULL);
     if (error)
       return error;
   }
 
-  // Don't allow write or execute access.
-  if (a_mode & (W_OK | X_OK))
+  int obj_mode = node->GetMode();
+  if (((a_mode & R_OK) && !(obj_mode & S_IREAD)) ||
+      ((a_mode & W_OK) && !(obj_mode & S_IWRITE)) ||
+      ((a_mode & X_OK) && !(obj_mode & S_IEXEC))) {
     return EACCES;
+  }
 
   return 0;
 }
 
 Error HttpFs::Open(const Path& path, int open_flags, ScopedNode* out_node) {
   out_node->reset(NULL);
 
-  NodeMap_t::iterator iter = node_cache_.find(path.Join());
-  if (iter != node_cache_.end()) {
-    *out_node = iter->second;
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() != NULL) {
+    *out_node = node;
     return 0;
   }
 
   // If we can't find the node in the cache, create it
   std::string url = MakeUrl(path);
-  ScopedNode node(new HttpFsNode(this, url, cache_content_));
+  node.reset(new HttpFsNode(this, url, cache_content_));
   Error error = node->Init(open_flags);
   if (error)
     return error;
 
   error = node->GetStat(NULL);
   if (error)
     return error;
 
   ScopedNode parent;
   error = FindOrCreateDir(path.Parent(), &parent);
   if (error)
     return error;
 
   error = parent->AddChild(path.Basename(), node);
   if (error)
     return error;
 
   node_cache_[path.Join()] = node;
   *out_node = node;
   return 0;
 }
 
-Error HttpFs::Unlink(const Path& path) {
+ScopedNode HttpFs::FindExistingNode(const Path& path) {
   NodeMap_t::iterator iter = node_cache_.find(path.Join());
   if (iter == node_cache_.end())
+    return ScopedNode();
+  return iter->second;
+}
+
+Error HttpFs::Unlink(const Path& path) {
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() == NULL)
     return ENOENT;
 
-  if (iter->second->IsaDir())
+  if (node->IsaDir())
     return EISDIR;
 
   return EACCES;
 }
 
 Error HttpFs::Mkdir(const Path& path, int permissions) {
-  NodeMap_t::iterator iter = node_cache_.find(path.Join());
-  if (iter != node_cache_.end()) {
-    if (iter->second->IsaDir())
-      return EEXIST;
-  }
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() != NULL && node->IsaDir())
+    return EEXIST;
+
   return EACCES;
 }
 
 Error HttpFs::Rmdir(const Path& path) {
-  NodeMap_t::iterator iter = node_cache_.find(path.Join());
-  if (iter == node_cache_.end())
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() == NULL)
     return ENOENT;
 
-  if (!iter->second->IsaDir())
+  if (!node->IsaDir())
     return ENOTDIR;
 
   return EACCES;
 }
 
 Error HttpFs::Remove(const Path& path) {
-  NodeMap_t::iterator iter = node_cache_.find(path.Join());
-  if (iter == node_cache_.end())
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() == NULL)
     return ENOENT;
 
   return EACCES;
 }
 
 Error HttpFs::Rename(const Path& path, const Path& newpath) {
-  NodeMap_t::iterator iter = node_cache_.find(path.Join());
-  if (iter == node_cache_.end())
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() == NULL)
     return ENOENT;
 
   return EACCES;
 }
 
 PP_Resource HttpFs::MakeUrlRequestInfo(const std::string& url,
                                        const char* method,
                                        StringMap_t* additional_headers) {
   URLRequestInfoInterface* interface = ppapi_->GetURLRequestInfoInterface();
   VarInterface* var_interface = ppapi_->GetVarInterface();
@@ skipping 38 matching lines @@
       PP_URLREQUESTPROPERTY_HEADERS,
       var_interface->VarFromUtf8(headers.c_str(), headers.length()));
 
   return request_info;
 }
 
 HttpFs::HttpFs()
     : allow_cors_(false),
       allow_credentials_(false),
       cache_stat_(true),
-      cache_content_(true) {
+      cache_content_(true),
+      is_blob_url_(false) {
 }
 
 Error HttpFs::Init(const FsInitArgs& args) {
   Error error = Filesystem::Init(args);
   if (error)
     return error;
 
   // Parse filesystem args.
   for (StringMap_t::const_iterator iter = args.string_map.begin();
        iter != args.string_map.end();
        ++iter) {
     if (iter->first == "SOURCE") {
       url_root_ = iter->second;
       is_blob_url_ = strncmp(url_root_.c_str(), "blob:", 5) == 0;
 
-      // Make sure url_root_ ends with a slash, except for blob URLs.
-      if (!is_blob_url_ && !url_root_.empty() &&
-          url_root_[url_root_.length() - 1] != '/') {
-        url_root_ += '/';
-      }
     } else if (iter->first == "manifest") {
       char* text;
       error = LoadManifest(iter->second, &text);
       if (error)
         return error;
 
       error = ParseManifest(text);
       if (error) {
         free(text);
         return error;
       }
 
       free(text);
     } else if (iter->first == "allow_cross_origin_requests") {
       allow_cors_ = iter->second == "true";
     } else if (iter->first == "allow_credentials") {
       allow_credentials_ = iter->second == "true";
     } else if (iter->first == "cache_stat") {
       cache_stat_ = iter->second == "true";
     } else if (iter->first == "cache_content") {
       cache_content_ = iter->second == "true";
     } else {
       // Assume it is a header to pass to an HTTP request.
       headers_[NormalizeHeaderKey(iter->first)] = iter->second;
     }
   }
 
+  if (!is_blob_url_) {
+    if (!url_root_.empty() && url_root_[url_root_.length() - 1] != '/') {
+      // Make sure url_root_ ends with a slash, except for blob URLs.
+      url_root_ += '/';
+    }
+
+    ScopedNode root;
+    error = FindOrCreateDir(Path("/"), &root);
+    if (error)
+      return error;
+  }
+
   return 0;
 }
 
 void HttpFs::Destroy() {
 }
 
 Error HttpFs::FindOrCreateDir(const Path& path, ScopedNode* out_node) {
   out_node->reset(NULL);
-  std::string strpath = path.Join();
-  NodeMap_t::iterator iter = node_cache_.find(strpath);
-  if (iter != node_cache_.end()) {
-    *out_node = iter->second;
+
+  ScopedNode node = FindExistingNode(path);
+  if (node.get() != NULL) {
+    *out_node = node;
     return 0;
   }
 
   // If the node does not exist, create it.
-  ScopedNode node(new DirNode(this));
+  node.reset(new DirNode(this));
   Error error = node->Init(0);
   if (error)
     return error;
+  // Directorys in http filesystems are never writable.
+  node->SetMode(node->GetMode() & ~S_IWALL);
 
   // If not the root node, find the parent node and add it to the parent
   if (!path.IsRoot()) {
     ScopedNode parent;
     error = FindOrCreateDir(path.Parent(), &parent);
     if (error)
       return error;
 
     error = parent->AddChild(path.Basename(), node);
     if (error)
       return error;
   }
 
   // Add it to the node cache.
-  node_cache_[strpath] = node;
+  node_cache_[path.Join()] = node;
   *out_node = node;
   return 0;
 }
 
 Error HttpFs::ParseManifest(const char* text) {
   std::vector<std::string> lines;
   sdk_util::SplitString(text, '\n', &lines);
 
   for (size_t i = 0; i < lines.size(); i++) {
     std::vector<std::string> words;
@@ skipping 11 matching lines @@
     if (non_empty_words.size() == 3) {
       const std::string& modestr = non_empty_words[0];
       const std::string& lenstr = non_empty_words[1];
       const std::string& name = non_empty_words[2];
 
       assert(modestr.size() == 4);
       assert(name[0] == '/');
 
       // Only support regular and streams for now
       // Ignore EXEC bit
-      int mode = S_IFREG;
+      int type = 0;
       switch (modestr[0]) {
         case '-':
-          mode = S_IFREG;
+          type = S_IFREG;
           break;
         case 'c':
-          mode = S_IFCHR;
+          type = S_IFCHR;
           break;
         default:
           LOG_ERROR("Unable to parse type %s for %s.",
                     modestr.c_str(),
                     name.c_str());
           return EINVAL;
       }
 
+      int mode = 0;
       switch (modestr[1]) {
         case '-':
           break;
         case 'r':
           mode |= S_IRUSR | S_IRGRP | S_IROTH;
           break;
         default:
           LOG_ERROR("Unable to parse read %s for %s.",
                     modestr.c_str(),
                     name.c_str());
@@ skipping 10 matching lines @@
           LOG_ERROR("Unable to parse write %s for %s.",
                     modestr.c_str(),
                     name.c_str());
           return EINVAL;
       }
 
       Path path(name);
       std::string url = MakeUrl(path);
 
       HttpFsNode* http_node = new HttpFsNode(this, url, cache_content_);
-      http_node->SetMode(mode);
       ScopedNode node(http_node);
+      node->SetMode(mode);
+      node->SetType(type);
 
       Error error = node->Init(0);
       if (error)
         return error;
       http_node->SetCachedSize(atoi(lenstr.c_str()));
 
       ScopedNode dir_node;
       error = FindOrCreateDir(path.Parent(), &dir_node);
       if (error)
         return error;
 
       error = dir_node->AddChild(path.Basename(), node);
       if (error)
         return error;
 
-      std::string pname = path.Join();
-      node_cache_[pname] = node;
+      node_cache_[path.Join()] = node;
     }
   }
 
   return 0;
 }
 
 Error HttpFs::LoadManifest(const std::string& manifest_name,
                            char** out_manifest) {
   Path manifest_path(manifest_name);
   ScopedNode manifest_node;
@@ skipping 21 matching lines @@
   *out_manifest = text;
   return 0;
 }
 
 std::string HttpFs::MakeUrl(const Path& path) {
   return url_root_ +
          (path.IsAbsolute() ? path.Range(1, path.Size()) : path.Join());
 }
 
 }  // namespace nacl_io