Home | History | Annotate | Download | only in test 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "base/test/test_file_util.h"
      6 
      7 #include <errno.h>
      8 #include <fcntl.h>
      9 #include <sys/stat.h>
     10 #include <sys/types.h>
     11 
     12 #include <string>
     13 
     14 #include "base/file_util.h"
     15 #include "base/files/file_path.h"
     16 #include "base/logging.h"
     17 #include "base/strings/string_util.h"
     18 #include "base/strings/utf_string_conversions.h"
     19 
     20 using base::MakeAbsoluteFilePath;
     21 
     22 namespace file_util {
     23 
     24 namespace {
     25 
     26 // Deny |permission| on the file |path|.
     27 bool DenyFilePermission(const base::FilePath& path, mode_t permission) {
     28   struct stat stat_buf;
     29   if (stat(path.value().c_str(), &stat_buf) != 0)
     30     return false;
     31   stat_buf.st_mode &= ~permission;
     32 
     33   int rv = HANDLE_EINTR(chmod(path.value().c_str(), stat_buf.st_mode));
     34   return rv == 0;
     35 }
     36 
     37 // Gets a blob indicating the permission information for |path|.
     38 // |length| is the length of the blob.  Zero on failure.
     39 // Returns the blob pointer, or NULL on failure.
     40 void* GetPermissionInfo(const base::FilePath& path, size_t* length) {
     41   DCHECK(length);
     42   *length = 0;
     43 
     44   struct stat stat_buf;
     45   if (stat(path.value().c_str(), &stat_buf) != 0)
     46     return NULL;
     47 
     48   *length = sizeof(mode_t);
     49   mode_t* mode = new mode_t;
     50   *mode = stat_buf.st_mode & ~S_IFMT;  // Filter out file/path kind.
     51 
     52   return mode;
     53 }
     54 
     55 // Restores the permission information for |path|, given the blob retrieved
     56 // using |GetPermissionInfo()|.
     57 // |info| is the pointer to the blob.
     58 // |length| is the length of the blob.
     59 // Either |info| or |length| may be NULL/0, in which case nothing happens.
     60 bool RestorePermissionInfo(const base::FilePath& path,
     61                            void* info, size_t length) {
     62   if (!info || (length == 0))
     63     return false;
     64 
     65   DCHECK_EQ(sizeof(mode_t), length);
     66   mode_t* mode = reinterpret_cast<mode_t*>(info);
     67 
     68   int rv = HANDLE_EINTR(chmod(path.value().c_str(), *mode));
     69 
     70   delete mode;
     71 
     72   return rv == 0;
     73 }
     74 
     75 }  // namespace
     76 
     77 bool DieFileDie(const base::FilePath& file, bool recurse) {
     78   // There is no need to workaround Windows problems on POSIX.
     79   // Just pass-through.
     80   return base::DeleteFile(file, recurse);
     81 }
     82 
     83 #if !defined(OS_LINUX) && !defined(OS_MACOSX)
     84 bool EvictFileFromSystemCache(const base::FilePath& file) {
     85   // There doesn't seem to be a POSIX way to cool the disk cache.
     86   NOTIMPLEMENTED();
     87   return false;
     88 }
     89 #endif
     90 
     91 std::wstring FilePathAsWString(const base::FilePath& path) {
     92   return UTF8ToWide(path.value());
     93 }
     94 base::FilePath WStringAsFilePath(const std::wstring& path) {
     95   return base::FilePath(WideToUTF8(path));
     96 }
     97 
     98 bool MakeFileUnreadable(const base::FilePath& path) {
     99   return DenyFilePermission(path, S_IRUSR | S_IRGRP | S_IROTH);
    100 }
    101 
    102 bool MakeFileUnwritable(const base::FilePath& path) {
    103   return DenyFilePermission(path, S_IWUSR | S_IWGRP | S_IWOTH);
    104 }
    105 
    106 PermissionRestorer::PermissionRestorer(const base::FilePath& path)
    107     : path_(path), info_(NULL), length_(0) {
    108   info_ = GetPermissionInfo(path_, &length_);
    109   DCHECK(info_ != NULL);
    110   DCHECK_NE(0u, length_);
    111 }
    112 
    113 PermissionRestorer::~PermissionRestorer() {
    114   if (!RestorePermissionInfo(path_, info_, length_))
    115     NOTREACHED();
    116 }
    117 
    118 }  // namespace file_util
    119