compiler-rt/lib/fuzzer/FuzzerIOPosix.cpp

   1 //===- FuzzerIOPosix.cpp - IO utils for Posix. ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // IO functions implementation using Posix API.
   9 //===----------------------------------------------------------------------===//
  10 #include "FuzzerPlatform.h"
  11 #if LIBFUZZER_POSIX || LIBFUZZER_FUCHSIA
  12
  13 #include "FuzzerExtFunctions.h"
  14 #include "FuzzerIO.h"
  15 #include <cstdarg>
  16 #include <cstdio>
  17 #include <dirent.h>
  18 #include <fstream>
  19 #include <iterator>
  20 #include <libgen.h>
  21 #include <sys/stat.h>
  22 #include <sys/types.h>
  23 #include <unistd.h>
  24
  25 namespace fuzzer {
  26
  27 bool IsFile(const std::string &Path) {
  28   struct stat St;
  29   if (stat(Path.c_str(), &St))
  30     return false;
  31   return S_ISREG(St.st_mode);
  32 }
  33
  34 bool IsDirectory(const std::string &Path) {
  35   struct stat St;
  36   if (stat(Path.c_str(), &St))
  37     return false;
  38   return S_ISDIR(St.st_mode);
  39 }
  40
  41 size_t FileSize(const std::string &Path) {
  42   struct stat St;
  43   if (stat(Path.c_str(), &St))
  44     return 0;
  45   return St.st_size;
  46 }
  47
  48 std::string Basename(const std::string &Path) {
  49   size_t Pos = Path.rfind(GetSeparator());
  50   if (Pos == std::string::npos) return Path;
  51   assert(Pos < Path.size());
  52   return Path.substr(Pos + 1);
  53 }
  54
  55 void ListFilesInDirRecursive(const std::string &Dir, long *Epoch,
  56                              std::vector<std::string> *V, bool TopDir) {
  57   auto E = GetEpoch(Dir);
  58   if (Epoch)
  59     if (E && *Epoch >= E) return;
  60
  61   DIR *D = opendir(Dir.c_str());
  62   if (!D) {
  63     Printf("%s: %s; exiting\n", strerror(errno), Dir.c_str());
  64     exit(1);
  65   }
  66   while (auto E = readdir(D)) {
  67     std::string Path = DirPlusFile(Dir, E->d_name);
  68     if (E->d_type == DT_REG || E->d_type == DT_LNK ||
  69         (E->d_type == DT_UNKNOWN && IsFile(Path)))
  70       V->push_back(Path);
  71     else if ((E->d_type == DT_DIR ||
  72              (E->d_type == DT_UNKNOWN && IsDirectory(Path))) &&
  73              *E->d_name != '.')
  74       ListFilesInDirRecursive(Path, Epoch, V, false);
  75   }
  76   closedir(D);
  77   if (Epoch && TopDir)
  78     *Epoch = E;
  79 }
  80
  81 void IterateDirRecursive(const std::string &Dir,
  82                          void (*DirPreCallback)(const std::string &Dir),
  83                          void (*DirPostCallback)(const std::string &Dir),
  84                          void (*FileCallback)(const std::string &Dir)) {
  85   DirPreCallback(Dir);
  86   DIR *D = opendir(Dir.c_str());
  87   if (!D) return;
  88   while (auto E = readdir(D)) {
  89     std::string Path = DirPlusFile(Dir, E->d_name);
  90     if (E->d_type == DT_REG || E->d_type == DT_LNK ||
  91         (E->d_type == DT_UNKNOWN && IsFile(Path)))
  92       FileCallback(Path);
  93     else if ((E->d_type == DT_DIR ||
  94              (E->d_type == DT_UNKNOWN && IsDirectory(Path))) &&
  95              *E->d_name != '.')
  96       IterateDirRecursive(Path, DirPreCallback, DirPostCallback, FileCallback);
  97   }
  98   closedir(D);
  99   DirPostCallback(Dir);
 100 }
 101
 102 char GetSeparator() {
 103   return '/';
 104 }
 105
 106 bool IsSeparator(char C) {
 107   return C == '/';
 108 }
 109
 110 FILE* OpenFile(int Fd, const char* Mode) {
 111   return fdopen(Fd, Mode);
 112 }
 113
 114 int CloseFile(int fd) {
 115   return close(fd);
 116 }
 117
 118 int DuplicateFile(int Fd) {
 119   return dup(Fd);
 120 }
 121
 122 void RemoveFile(const std::string &Path) {
 123   unlink(Path.c_str());
 124 }
 125
 126 void RenameFile(const std::string &OldPath, const std::string &NewPath) {
 127   rename(OldPath.c_str(), NewPath.c_str());
 128 }
 129
 130 intptr_t GetHandleFromFd(int fd) {
 131   return static_cast<intptr_t>(fd);
 132 }
 133
 134 std::string DirName(const std::string &FileName) {
 135   char *Tmp = new char[FileName.size() + 1];
 136   memcpy(Tmp, FileName.c_str(), FileName.size() + 1);
 137   std::string Res = dirname(Tmp);
 138   delete [] Tmp;
 139   return Res;
 140 }
 141
 142 std::string TmpDir() {
 143   if (auto Env = getenv("TMPDIR"))
 144     return Env;
 145   return "/tmp";
 146 }
 147
 148 bool IsInterestingCoverageFile(const std::string &FileName) {
 149   if (FileName.find("compiler-rt/lib/") != std::string::npos)
 150     return false; // sanitizer internal.
 151   if (FileName.find("/usr/lib/") != std::string::npos)
 152     return false;
 153   if (FileName.find("/usr/include/") != std::string::npos)
 154     return false;
 155   if (FileName == "<null>")
 156     return false;
 157   return true;
 158 }
 159
 160 void RawPrint(const char *Str) {
 161   (void)write(2, Str, strlen(Str));
 162 }
 163
 164 void MkDir(const std::string &Path) {
 165   mkdir(Path.c_str(), 0700);
 166 }
 167
 168 void RmDir(const std::string &Path) {
 169   rmdir(Path.c_str());
 170 }
 171
 172 const std::string &getDevNull() {
 173   static const std::string devNull = "/dev/null";
 174   return devNull;
 175 }
 176
 177 }  // namespace fuzzer
 178
 179 #endif // LIBFUZZER_POSIX