1 //===- FuzzerCommand.h - Interface representing a process -------*- C++ -* ===// 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 // FuzzerCommand represents a command to run in a subprocess. It allows callers 9 // to manage command line arguments and output and error streams. 10 //===----------------------------------------------------------------------===// 11 12 #ifndef LLVM_FUZZER_COMMAND_H 13 #define LLVM_FUZZER_COMMAND_H 14 15 #include "FuzzerDefs.h" 16 #include "FuzzerIO.h" 17 18 #include <algorithm> 19 #include <sstream> 20 #include <string> 21 #include <vector> 22 #include <thread> 23 24 namespace fuzzer { 25 26 class Command final { 27 public: 28 // This command line flag is used to indicate that the remaining command line 29 // is immutable, meaning this flag effectively marks the end of the mutable 30 // argument list. 31 static inline const char *ignoreRemainingArgs() { 32 return "-ignore_remaining_args=1"; 33 } 34 35 Command() : CombinedOutAndErr(false) {} 36 37 explicit Command(const std::vector<std::string> &ArgsToAdd) 38 : Args(ArgsToAdd), CombinedOutAndErr(false) {} 39 40 explicit Command(const Command &Other) 41 : Args(Other.Args), CombinedOutAndErr(Other.CombinedOutAndErr), 42 OutputFile(Other.OutputFile) {} 43 44 Command &operator=(const Command &Other) { 45 Args = Other.Args; 46 CombinedOutAndErr = Other.CombinedOutAndErr; 47 OutputFile = Other.OutputFile; 48 return *this; 49 } 50 51 ~Command() {} 52 53 // Returns true if the given Arg is present in Args. Only checks up to 54 // "-ignore_remaining_args=1". 55 bool hasArgument(const std::string &Arg) const { 56 auto i = endMutableArgs(); 57 return std::find(Args.begin(), i, Arg) != i; 58 } 59 60 // Gets all of the current command line arguments, **including** those after 61 // "-ignore-remaining-args=1". 62 const std::vector<std::string> &getArguments() const { return Args; } 63 64 // Adds the given argument before "-ignore_remaining_args=1", or at the end 65 // if that flag isn't present. 66 void addArgument(const std::string &Arg) { 67 Args.insert(endMutableArgs(), Arg); 68 } 69 70 // Adds all given arguments before "-ignore_remaining_args=1", or at the end 71 // if that flag isn't present. 72 void addArguments(const std::vector<std::string> &ArgsToAdd) { 73 Args.insert(endMutableArgs(), ArgsToAdd.begin(), ArgsToAdd.end()); 74 } 75 76 // Removes the given argument from the command argument list. Ignores any 77 // occurrences after "-ignore_remaining_args=1", if present. 78 void removeArgument(const std::string &Arg) { 79 auto i = endMutableArgs(); 80 Args.erase(std::remove(Args.begin(), i, Arg), i); 81 } 82 83 // Like hasArgument, but checks for "-[Flag]=...". 84 bool hasFlag(const std::string &Flag) const { 85 std::string Arg("-" + Flag + "="); 86 auto IsMatch = [&](const std::string &Other) { 87 return Arg.compare(0, std::string::npos, Other, 0, Arg.length()) == 0; 88 }; 89 return std::any_of(Args.begin(), endMutableArgs(), IsMatch); 90 } 91 92 // Returns the value of the first instance of a given flag, or an empty string 93 // if the flag isn't present. Ignores any occurrences after 94 // "-ignore_remaining_args=1", if present. 95 std::string getFlagValue(const std::string &Flag) const { 96 std::string Arg("-" + Flag + "="); 97 auto IsMatch = [&](const std::string &Other) { 98 return Arg.compare(0, std::string::npos, Other, 0, Arg.length()) == 0; 99 }; 100 auto i = endMutableArgs(); 101 auto j = std::find_if(Args.begin(), i, IsMatch); 102 std::string result; 103 if (j != i) { 104 result = j->substr(Arg.length()); 105 } 106 return result; 107 } 108 109 // Like AddArgument, but adds "-[Flag]=[Value]". 110 void addFlag(const std::string &Flag, const std::string &Value) { 111 addArgument("-" + Flag + "=" + Value); 112 } 113 114 // Like RemoveArgument, but removes "-[Flag]=...". 115 void removeFlag(const std::string &Flag) { 116 std::string Arg("-" + Flag + "="); 117 auto IsMatch = [&](const std::string &Other) { 118 return Arg.compare(0, std::string::npos, Other, 0, Arg.length()) == 0; 119 }; 120 auto i = endMutableArgs(); 121 Args.erase(std::remove_if(Args.begin(), i, IsMatch), i); 122 } 123 124 // Returns whether the command's stdout is being written to an output file. 125 bool hasOutputFile() const { return !OutputFile.empty(); } 126 127 // Returns the currently set output file. 128 const std::string &getOutputFile() const { return OutputFile; } 129 130 // Configures the command to redirect its output to the name file. 131 void setOutputFile(const std::string &FileName) { OutputFile = FileName; } 132 133 // Returns whether the command's stderr is redirected to stdout. 134 bool isOutAndErrCombined() const { return CombinedOutAndErr; } 135 136 // Sets whether to redirect the command's stderr to its stdout. 137 void combineOutAndErr(bool combine = true) { CombinedOutAndErr = combine; } 138 139 // Returns a string representation of the command. On many systems this will 140 // be the equivalent command line. 141 std::string toString() const { 142 std::stringstream SS; 143 for (const auto &arg : getArguments()) 144 SS << arg << " "; 145 if (hasOutputFile()) 146 SS << ">" << getOutputFile() << " "; 147 if (isOutAndErrCombined()) 148 SS << "2>&1 "; 149 std::string result = SS.str(); 150 if (!result.empty()) 151 result = result.substr(0, result.length() - 1); 152 return result; 153 } 154 155 private: 156 Command(Command &&Other) = delete; 157 Command &operator=(Command &&Other) = delete; 158 159 std::vector<std::string>::iterator endMutableArgs() { 160 return std::find(Args.begin(), Args.end(), ignoreRemainingArgs()); 161 } 162 163 std::vector<std::string>::const_iterator endMutableArgs() const { 164 return std::find(Args.begin(), Args.end(), ignoreRemainingArgs()); 165 } 166 167 // The command arguments. Args[0] is the command name. 168 std::vector<std::string> Args; 169 170 // True indicates stderr is redirected to stdout. 171 bool CombinedOutAndErr; 172 173 // If not empty, stdout is redirected to the named file. 174 std::string OutputFile; 175 }; 176 177 } // namespace fuzzer 178 179 #endif // LLVM_FUZZER_COMMAND_H 180