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

The root of all filesystems should be a directory node
except in the special case of blob URL where we maintain
the legacy behavior of having the mount point be a file
containing the blob content.

Also, fix the Access() call for http filesystem so that
it honors the access bits of the node itself.

This fixes an issue in naclports where a mount() of
an http filsystem followed by a chdir(http_root) would
always fail with ENOTDIR.

TEST=nacl_io_test

Review URL: https://codereview.chromium.org/547713002

Cr-Commit-Position: refs/heads/master@{#294000}

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

@@ -42,11 +42,11 @@ std::string NormalizeHeaderKey(const std::string& s) {
 }
 
 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;
@@ -56,9 +56,12 @@ Error HttpFs::Access(const Path& path, int a_mode) {
       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;
 }
@@ -66,15 +69,15 @@ Error HttpFs::Access(const Path& path, int a_mode) {
 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;
@@ -97,48 +100,54 @@ Error HttpFs::Open(const Path& path, int open_flags, ScopedNode* out_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;
@@ -197,7 +206,8 @@ 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) {
@@ -213,11 +223,6 @@ Error HttpFs::Init(const FsInitArgs& args) {
       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);
@@ -245,6 +250,18 @@ Error HttpFs::Init(const FsInitArgs& args) {
     }
   }
 
+  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;
 }
 
@@ -253,18 +270,20 @@ 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()) {
@@ -279,7 +298,7 @@ Error HttpFs::FindOrCreateDir(const Path& path, ScopedNode* out_node) {
   }
 
   // Add it to the node cache.
-  node_cache_[strpath] = node;
+  node_cache_[path.Join()] = node;
   *out_node = node;
   return 0;
 }
@@ -311,13 +330,13 @@ Error HttpFs::ParseManifest(const char* text) {
 
       // 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.",
@@ -326,6 +345,7 @@ Error HttpFs::ParseManifest(const char* text) {
           return EINVAL;
       }
 
+      int mode = 0;
       switch (modestr[1]) {
         case '-':
           break;
@@ -356,8 +376,9 @@ Error HttpFs::ParseManifest(const char* text) {
       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)
@@ -373,8 +394,7 @@ Error HttpFs::ParseManifest(const char* text) {
       if (error)
         return error;
 
-      std::string pname = path.Join();
-      node_cache_[pname] = node;
+      node_cache_[path.Join()] = node;
     }
   }
 

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

@@ -35,6 +35,7 @@ class HttpFs : public Filesystem {
 
   virtual Error Init(const FsInitArgs& args);
   virtual void Destroy();
+  ScopedNode FindExistingNode(const Path& path);
   Error FindOrCreateDir(const Path& path, ScopedNode* out_node);
   Error LoadManifest(const std::string& path, char** out_manifest);
   Error ParseManifest(const char* text);

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

@@ -232,10 +232,8 @@ HttpFsNode::HttpFsNode(Filesystem* filesystem,
       buffer_len_(0),
       cache_content_(cache_content),
       has_cached_size_(false) {
-}
-
-void HttpFsNode::SetMode(int mode) {
-  stat_.st_mode = mode;
+  // http nodes are read-only by default
+  SetMode(S_IRALL);
 }
 
 Error HttpFsNode::GetStat_Locked(struct stat* stat) {
@@ -297,7 +295,7 @@ Error HttpFsNode::GetStat_Locked(struct stat* stat) {
     stat_.st_mtime = 0;
     stat_.st_ctime = 0;
 
-    stat_.st_mode |= S_IFREG;
+    SetType(S_IFREG);
   }
 
   // Fill the stat structure if provided

native_client_sdk/src/libraries/nacl_io/httpfs/http_fs_node.h

@@ -37,7 +37,6 @@ class HttpFsNode : public Node {
   virtual Error GetSize(off_t* out_size);
 
   void SetCachedSize(off_t size);
-  void SetMode(int mode);
 
  protected:
   HttpFsNode(Filesystem* filesystem,

native_client_sdk/src/libraries/nacl_io/node.cc

@@ -199,6 +199,12 @@ void Node::SetType(int type) {
   stat_.st_mode |= type;
 }
 
+void Node::SetMode(int mode) {
+  assert((mode & S_IFMT) == 0);
+  stat_.st_mode &= S_IFMT;
+  stat_.st_mode |= mode;
+}
+
 bool Node::IsaDir() {
   return GetType() == S_IFDIR;
 }

native_client_sdk/src/libraries/nacl_io/node.h

@@ -92,6 +92,7 @@ class Node : public sdk_util::RefObject {
 
   virtual int GetLinks();
   virtual int GetMode();
+  virtual void SetMode(int mode);
   virtual int GetType();
   virtual void SetType(int type);
   // Assume that |out_size| is non-NULL.

native_client_sdk/src/tests/nacl_io_test/http_fs_test.cc

@@ -178,8 +178,7 @@ TEST_P(HttpFsTest, GetStat) {
 
   struct stat statbuf;
   EXPECT_EQ(0, node->GetStat(&statbuf));
-  EXPECT_EQ(S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH,
-            statbuf.st_mode);
+  EXPECT_EQ(S_IFREG | S_IRUSR | S_IRGRP | S_IROTH, statbuf.st_mode);
   EXPECT_EQ(strlen(contents), statbuf.st_size);
   // These are not currently set.
   EXPECT_EQ(0, statbuf.st_atime);
@@ -253,8 +252,7 @@ TEST_P(HttpFsLargeFileTest, GetStat) {
 
   struct stat statbuf;
   EXPECT_EQ(0, node->GetStat(&statbuf));
-  EXPECT_EQ(S_IFREG | S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH,
-            statbuf.st_mode);
+  EXPECT_EQ(S_IFREG | S_IRUSR | S_IRGRP | S_IROTH, statbuf.st_mode);
   EXPECT_EQ(size, statbuf.st_size);
   // These are not currently set.
   EXPECT_EQ(0, statbuf.st_atime);
@@ -270,6 +268,21 @@ INSTANTIATE_TEST_CASE_P(Default,
                         ::testing::Values((uint32_t)kStringMapParamCacheNone,
                                           (uint32_t)kStringMapParamCacheStat));
 
+TEST(HttpFsDirTest, Root) {
+  StringMap_t args;
+  HttpFsForTesting fs(args, NULL);
+
+  // Check root node is directory
+  ScopedNode node;
+  ASSERT_EQ(0, fs.Open(Path("/"), O_RDONLY, &node));
+  ASSERT_TRUE(node->IsaDir());
+
+  // We have to r+w access to the root node
+  ASSERT_EQ(0, fs.Access(Path("/"), R_OK));
+  ASSERT_EQ(0, fs.Access(Path("/"), X_OK));
+  ASSERT_EQ(EACCES, fs.Access(Path("/"), W_OK));
+}
+
 TEST(HttpFsDirTest, Mkdir) {
   StringMap_t args;
   HttpFsForTesting fs(args, NULL);
@@ -369,24 +382,30 @@ TEST(HttpFsDirTest, ParseManifest) {
 }
 
 TEST(HttpFsBlobUrlTest, Basic) {
-  const char* kUrl =
-      "blob:http%3A//example.com/6b87a5a6-713e-46a4-9f0c-78066406455d";
+  const char* kUrl = "blob:http%3A//example.com/6b87a5a6-713e";
+  const char* kContent = "hello";
   FakePepperInterfaceURLLoader ppapi;
-  ASSERT_TRUE(ppapi.server_template()->SetBlobEntity(kUrl, "", NULL));
+  ASSERT_TRUE(ppapi.server_template()->SetBlobEntity(kUrl, kContent, NULL));
 
   StringMap_t args;
   args["SOURCE"] = kUrl;
 
   HttpFsForTesting fs(args, &ppapi);
 
-  // We have to read from the mount root to read a Blob URL.
+  // Check access to root folder
   ASSERT_EQ(0, fs.Access(Path("/"), R_OK));
   ASSERT_EQ(EACCES, fs.Access(Path("/"), W_OK));
   ASSERT_EQ(EACCES, fs.Access(Path("/"), X_OK));
 
   // Any other path will fail.
   ScopedNode foo;
-  ASSERT_EQ(ENOENT, fs.Access(Path(""), R_OK));
-  ASSERT_EQ(ENOENT, fs.Access(Path("."), R_OK));
-  ASSERT_EQ(ENOENT, fs.Access(Path("blah"), R_OK));
+  ASSERT_EQ(ENOENT, fs.Access(Path("/blah"), R_OK));
+
+  // Verify file size
+  ScopedNode node;
+  struct stat statbuf;
+  ASSERT_EQ(0, fs.Open(Path("/"), O_RDONLY, &node));
+  ASSERT_EQ(0, node->GetStat(&statbuf));
+  ASSERT_EQ(0, node->GetStat(&statbuf));
+  ASSERT_EQ(strlen(kContent), statbuf.st_size);
 }