[NaCl SDK] nacl_io: Add chmod/fchmod

native_client_sdk/src/tests/nacl_io_test/fuse_fs_test.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 <fcntl.h>
 
 #include <gtest/gtest.h>
 
 #include <string>
 #include <vector>
@@ skipping 13 matching lines @@
  public:
   explicit FuseFsForTesting(fuse_operations* fuse_ops) {
     FsInitArgs args;
     args.fuse_ops = fuse_ops;
     EXPECT_EQ(0, Init(args));
   }
 };
 
 // Implementation of a simple flat memory filesystem.
 struct File {
-  File() {
-    memset(&times, 0, sizeof(times));
-  }
+  File() : mode(0666) { memset(&times, 0, sizeof(times)); }
 
   std::string name;
   std::vector<uint8_t> data;
+  mode_t mode;
   timespec times[2];
 };
 
 typedef std::vector<File> Files;
 Files g_files;
-mode_t last_create_mode = 0666;
 
 bool IsValidPath(const char* path) {
   if (path == NULL)
     return false;
 
   if (strlen(path) <= 1)
     return false;
 
   if (path[0] != '/')
     return false;
@@ skipping 18 matching lines @@
 
   if (strcmp(path, "/") == 0) {
     stbuf->st_mode = S_IFDIR | 0755;
     return 0;
   }
 
   File* file = FindFile(path);
   if (file == NULL)
     return -ENOENT;
 
-  stbuf->st_mode = S_IFREG | last_create_mode;
+  stbuf->st_mode = S_IFREG | file->mode;
   stbuf->st_size = file->data.size();
   stbuf->st_atime = file->times[0].tv_sec;
   stbuf->st_atimensec = file->times[0].tv_nsec;
   stbuf->st_mtime = file->times[1].tv_sec;
   stbuf->st_mtimensec = file->times[1].tv_nsec;
   return 0;
 }
 
 int testfs_readdir(const char* path,
                    void* buf,
@@ skipping 17 matching lines @@
 
   File* file = FindFile(path);
   if (file != NULL) {
     if (fi->flags & O_EXCL)
       return -EEXIST;
   } else {
     g_files.push_back(File());
     file = &g_files.back();
     file->name = &path[1];  // Skip initial /
   }
-  last_create_mode = mode;
+  file->mode = mode;
 
   return 0;
 }
 
 int testfs_open(const char* path, struct fuse_file_info*) {
   // open is only called to open an existing file, otherwise create is
   // called. We don't need to do any additional work here, the path will be
   // passed to any other operations.
   return FindFile(path) != NULL;
 }
@@ skipping 40 matching lines @@
 int testfs_utimens(const char* path, const struct timespec times[2]) {
   File* file = FindFile(path);
   if (file == NULL)
     return -ENOENT;
 
   file->times[0] = times[0];
   file->times[1] = times[1];
   return 0;
 }
 
+int testfs_chmod(const char* path, mode_t mode) {
+  File* file = FindFile(path);
+  if (file == NULL)
+    return -ENOENT;
+
+  file->mode = mode;
+  return 0;
+}
+
 const char hello_world[] = "Hello, World!\n";
 
 fuse_operations g_fuse_operations = {
     0,               // flag_nopath
     0,               // flag_reserved
+    testfs_getattr,  // getattr
+    NULL,            // readlink
+    NULL,            // mknod
+    NULL,            // mkdir
+    NULL,            // unlink
+    NULL,            // rmdir
+    NULL,            // symlink
+    NULL,            // rename
+    NULL,            // link
+    testfs_chmod,    // chmod
+    NULL,            // chown
+    NULL,            // truncate
+    testfs_open,     // open
+    testfs_read,     // read
+    testfs_write,    // write
+    NULL,            // statfs
+    NULL,            // flush
+    NULL,            // release
+    NULL,            // fsync
+    NULL,            // setxattr
+    NULL,            // getxattr
+    NULL,            // listxattr
+    NULL,            // removexattr
+    NULL,            // opendir
+    testfs_readdir,  // readdir
+    NULL,            // releasedir
+    NULL,            // fsyncdir
     NULL,            // init
     NULL,            // destroy
     NULL,            // access
     testfs_create,   // create
+    NULL,            // ftruncate
     NULL,            // fgetattr
-    NULL,            // fsync
-    NULL,            // ftruncate
-    testfs_getattr,  // getattr
-    NULL,            // mkdir
-    NULL,            // mknod
-    testfs_open,     // open
-    NULL,            // opendir
-    testfs_read,     // read
-    testfs_readdir,  // readdir
-    NULL,            // release
-    NULL,            // releasedir
-    NULL,            // rename
-    NULL,            // rmdir
-    NULL,            // truncate
-    NULL,            // unlink
-    testfs_write,    // write
+    NULL,            // lock
     testfs_utimens,  // utimens
+    NULL,            // bmap
+    NULL,            // ioctl
+    NULL,            // poll
+    NULL,            // write_buf
+    NULL,            // read_buf
+    NULL,            // flock
+    NULL,            // fallocate
 };
 
 class FuseFsTest : public ::testing::Test {
  public:
   FuseFsTest();
 
   void SetUp();
 
  protected:
   FuseFsForTesting fs_;
@@ skipping 134 matching lines @@
   ASSERT_EQ(0, fs_.Open(Path("/hello"), O_RDONLY, &node));
   EXPECT_EQ(0, node->Futimens(times));
 
   EXPECT_EQ(0, node->GetStat(&statbuf));
   EXPECT_EQ(times[0].tv_sec, statbuf.st_atime);
   EXPECT_EQ(times[0].tv_nsec, statbuf.st_atimensec);
   EXPECT_EQ(times[1].tv_sec, statbuf.st_mtime);
   EXPECT_EQ(times[1].tv_nsec, statbuf.st_mtimensec);
 }
 
+TEST_F(FuseFsTest, Fchmod) {
+  struct stat statbuf;
+  ScopedNode node;
+
+  ASSERT_EQ(0, fs_.Open(Path("/hello"), O_RDONLY, &node));
+  ASSERT_EQ(0, node->GetStat(&statbuf));
+  EXPECT_EQ(0666, statbuf.st_mode & ~S_IFMT);
+
+  ASSERT_EQ(0, node->Fchmod(0777));
+
+  ASSERT_EQ(0, node->GetStat(&statbuf));
+  EXPECT_EQ(0777, statbuf.st_mode & ~S_IFMT);
+}
+
 namespace {
 
 class KernelProxyFuseTest : public ::testing::Test {
  public:
   KernelProxyFuseTest() {}
 
   void SetUp();
   void TearDown();
 
  private:
@@ skipping 30 matching lines @@
   // Then read it back in.
   fd = ki_open("/hello", O_RDONLY, 0);
   ASSERT_GT(fd, -1);
 
   char buffer[30];
   memset(buffer, 0, sizeof(buffer));
   ASSERT_EQ(sizeof(hello_world), ki_read(fd, buffer, sizeof(buffer)));
   EXPECT_STREQ(hello_world, buffer);
   EXPECT_EQ(0, ki_close(fd));
 }