36#if defined(PROVIDE_FUZZ_MAIN_FUNCTION) && defined(__AFL_FUZZ_INIT)
49static std::vector<const char*>
g_args;
51static void SetArgs(
int argc,
char** argv) {
52 for (
int i = 1; i < argc; ++i) {
55 if (strlen(argv[i]) > 2 && argv[i][0] ==
'-' && argv[i][1] ==
'-') {
72 static std::map<std::string_view, FuzzTarget> g_fuzz_targets;
73 return g_fuzz_targets;
108 CreateSock = [](int, int, int) -> std::unique_ptr<Sock> { std::terminate(); };
118 bool should_exit{
false};
119 if (std::getenv(
"PRINT_ALL_FUZZ_TARGETS_AND_ABORT")) {
121 if (
t.opts.hidden)
continue;
122 std::cout <<
name << std::endl;
126 if (
const char* out_path = std::getenv(
"WRITE_ALL_FUZZ_TARGETS_AND_ABORT")) {
127 std::cout <<
"Writing all fuzz target names to '" << out_path <<
"'." << std::endl;
128 std::ofstream out_stream{out_path, std::ios::binary};
130 if (
t.opts.hidden)
continue;
131 out_stream <<
name << std::endl;
138 if (
const auto* env_fuzz{std::getenv(
"FUZZ")}) {
140 static std::string g_copy{env_fuzz};
143 std::cerr <<
"Must select fuzz target with the FUZZ env var." << std::endl;
144 std::cerr <<
"Hint: Set the PRINT_ALL_FUZZ_TARGETS_AND_ABORT=1 env var to see all compiled targets." << std::endl;
145 std::exit(EXIT_FAILURE);
149 std::cerr <<
"No fuzz target compiled for " <<
g_fuzz_target <<
"." << std::endl;
150 std::exit(EXIT_FAILURE);
153 std::cerr <<
"Must compile with -DBUILD_FOR_FUZZING=ON to execute a fuzz target." << std::endl;
154 std::exit(EXIT_FAILURE);
158 it->second.opts.init();
163#if defined(PROVIDE_FUZZ_MAIN_FUNCTION)
164static bool read_stdin(std::vector<uint8_t>&
data)
166 std::istream::char_type buffer[1024];
167 std::streamsize length;
168 while ((std::cin.read(buffer, 1024), length = std::cin.gcount()) > 0) {
169 data.insert(
data.end(), buffer, buffer + length);
175#if defined(PROVIDE_FUZZ_MAIN_FUNCTION) && !defined(__AFL_LOOP)
176static bool read_file(fs::path p, std::vector<uint8_t>&
data)
178 uint8_t buffer[1024];
180 if (f ==
nullptr)
return false;
182 const size_t length = fread(buffer,
sizeof(uint8_t),
sizeof(buffer), f);
183 if (ferror(f))
return false;
184 data.insert(
data.end(), buffer, buffer + length);
191#if defined(PROVIDE_FUZZ_MAIN_FUNCTION) && !defined(__AFL_LOOP)
192static fs::path g_input_path;
193void signal_handler(
int signal)
195 if (signal == SIGABRT) {
196 std::cerr <<
"Error processing input " << g_input_path << std::endl;
198 std::cerr <<
"Unexpected signal " << signal <<
" received\n";
200 std::_Exit(EXIT_FAILURE);
219#if defined(PROVIDE_FUZZ_MAIN_FUNCTION)
220int main(
int argc,
char** argv)
226 const uint8_t* buffer = __AFL_FUZZ_TESTCASE_BUF;
227 while (__AFL_LOOP(100000)) {
228 size_t buffer_len = __AFL_FUZZ_TESTCASE_LEN;
232 std::vector<uint8_t> buffer;
234 if (!read_stdin(buffer)) {
240 std::signal(SIGABRT, signal_handler);
241 const auto start_time{Now<SteadySeconds>()};
243 for (
int i = 1; i < argc; ++i) {
244 fs::path input_path(*(argv + i));
245 if (fs::is_directory(input_path)) {
246 std::vector<fs::path> files;
247 for (fs::directory_iterator it(input_path); it != fs::directory_iterator(); ++it) {
248 if (!fs::is_regular_file(it->path()))
continue;
249 files.emplace_back(it->path());
251 std::ranges::shuffle(files, std::mt19937{std::random_device{}()});
252 for (
const auto& input_path : files) {
253 g_input_path = input_path;
254 Assert(read_file(input_path, buffer));
260 g_input_path = input_path;
261 Assert(read_file(input_path, buffer));
267 const auto end_time{Now<SteadySeconds>()};
268 std::cout <<
g_fuzz_target <<
": succeeded against " << tested <<
" files in " <<
count_seconds(end_time - start_time) <<
"s." << std::endl;
int main(int argc, char **argv)
#define Assert(val)
Identity function.
void ResetCoverageCounters()
static void test_one_input(FuzzBufferType buffer)
void FuzzFrameworkRegisterTarget(std::string_view name, TypeTestOneInput target, FuzzTargetOptions opts)
const std::function< void(const std::string &)> G_TEST_LOG_FUN
This is connected to the logger.
static const TypeTestOneInput * g_test_one_input
static void SetArgs(int argc, char **argv)
const std::function< std::vector< const char * >()> G_TEST_COMMAND_LINE_ARGUMENTS
Retrieve the command line arguments.
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
int LLVMFuzzerInitialize(int *argc, char ***argv)
static std::string_view g_fuzz_target
static std::vector< const char * > g_args
A copy of the command line arguments that start with --.
const std::function< std::string()> G_TEST_GET_FULL_NAME
Retrieve the unit test name.
std::span< const uint8_t > FuzzBufferType
std::function< void(FuzzBufferType)> TypeTestOneInput
FILE * fopen(const fs::path &p, const char *mode)
std::function< std::unique_ptr< Sock >(int, int, int)> CreateSock
Socket factory.
std::vector< CNetAddr > WrappedGetAddrInfo(const std::string &name, bool allow_lookup)
Wrapper for getaddrinfo(3).
const TypeTestOneInput test_one_input
const FuzzTargetOptions opts
void SeedRandomStateForTest(SeedRand seedtype)
Seed the global RNG state for testing and log the seed value.
@ ZEROS
Seed with a compile time constant of zeros.
void SetMockTime(int64_t nMockTimeIn)
DEPRECATED Use SetMockTime with chrono type.
constexpr int64_t count_seconds(std::chrono::seconds t)