robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 1 | /* |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 2 | * |
robert.swiecki@gmail.com | 90e9911 | 2015-02-15 02:05:14 +0000 | [diff] [blame] | 3 | * honggfuzz - the main file |
| 4 | * ----------------------------------------- |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 5 | * |
Robert Swiecki | 46288f7 | 2018-02-27 17:28:47 +0100 | [diff] [blame] | 6 | * Authors: Robert Swiecki <swiecki@google.com> |
| 7 | * Felix Gröbert <groebert@google.com> |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 8 | * |
Robert Swiecki | dacf91a | 2019-02-11 15:09:16 +0100 | [diff] [blame] | 9 | * Copyright 2010-2019 by Google Inc. All Rights Reserved. |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 10 | * |
| 11 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 12 | * not use this file except in compliance with the License. You may obtain |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 13 | * a copy of the License at |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 14 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 15 | * http://www.apache.org/licenses/LICENSE-2.0 |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 16 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 17 | * Unless required by applicable law or agreed to in writing, software |
| 18 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 19 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or |
| 20 | * implied. See the License for the specific language governing |
| 21 | * permissions and limitations under the License. |
robert.swiecki@gmail.com | 3b630b4 | 2015-02-16 10:53:53 +0000 | [diff] [blame] | 22 | * |
robert.swiecki@gmail.com | 772b33d | 2015-02-14 20:35:00 +0000 | [diff] [blame] | 23 | */ |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 24 | |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 25 | #include <errno.h> |
robert.swiecki@gmail.com | ba85c3e | 2015-02-02 14:55:16 +0000 | [diff] [blame] | 26 | #include <getopt.h> |
Robert Swiecki | d0fa62c | 2017-09-28 18:11:05 +0200 | [diff] [blame] | 27 | #include <inttypes.h> |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 28 | #include <signal.h> |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 29 | #include <stdio.h> |
| 30 | #include <stdlib.h> |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 31 | #include <string.h> |
Robert Swiecki | 10eeb0a | 2017-09-28 15:42:52 +0200 | [diff] [blame] | 32 | #include <sys/mman.h> |
Robert Swiecki | 087ff53 | 2018-01-16 22:28:07 +0100 | [diff] [blame] | 33 | #include <sys/resource.h> |
| 34 | #include <sys/time.h> |
robert.swiecki@gmail.com | ba85c3e | 2015-02-02 14:55:16 +0000 | [diff] [blame] | 35 | #include <time.h> |
| 36 | #include <unistd.h> |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 37 | |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 38 | #include "cmdline.h" |
Robert Swiecki | a375f4b | 2017-06-01 13:20:54 +0200 | [diff] [blame] | 39 | #include "display.h" |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 40 | #include "fuzz.h" |
Robert Swiecki | 10eeb0a | 2017-09-28 15:42:52 +0200 | [diff] [blame] | 41 | #include "input.h" |
Robert Swiecki | 246af3e | 2018-01-05 14:56:32 +0100 | [diff] [blame] | 42 | #include "libhfcommon/common.h" |
| 43 | #include "libhfcommon/files.h" |
| 44 | #include "libhfcommon/log.h" |
| 45 | #include "libhfcommon/util.h" |
Robert Swiecki | 5627619 | 2018-01-21 15:43:02 +0100 | [diff] [blame] | 46 | #include "socketfuzzer.h" |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 47 | #include "subproc.h" |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 48 | |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 49 | static int sigReceived = 0; |
| 50 | |
Robert Swiecki | c6a48b1 | 2016-03-11 17:41:57 +0100 | [diff] [blame] | 51 | /* |
| 52 | * CygWin/MinGW incorrectly copies stack during fork(), so we need to keep some |
| 53 | * structures in the data section |
| 54 | */ |
| 55 | honggfuzz_t hfuzz; |
Robert Swiecki | c6a48b1 | 2016-03-11 17:41:57 +0100 | [diff] [blame] | 56 | |
Robert Swiecki | 35978ac | 2017-11-16 18:00:53 +0100 | [diff] [blame] | 57 | static void exitWithMsg(const char* msg, int exit_code) { |
Robert Swiecki | f90fb15 | 2018-01-08 15:30:03 +0100 | [diff] [blame] | 58 | HF_ATTR_UNUSED ssize_t sz = write(STDERR_FILENO, msg, strlen(msg)); |
Robert Swiecki | 8b4cc33 | 2018-10-12 17:10:00 +0200 | [diff] [blame] | 59 | for (;;) { |
| 60 | exit(exit_code); |
Robert Swiecki | d7f594e | 2019-01-26 18:28:57 +0100 | [diff] [blame] | 61 | _exit(exit_code); |
Robert Swiecki | 8b4cc33 | 2018-10-12 17:10:00 +0200 | [diff] [blame] | 62 | abort(); |
Robert Swiecki | d7f594e | 2019-01-26 18:28:57 +0100 | [diff] [blame] | 63 | __builtin_trap(); |
Robert Swiecki | 8b4cc33 | 2018-10-12 17:10:00 +0200 | [diff] [blame] | 64 | } |
Robert Swiecki | 35978ac | 2017-11-16 18:00:53 +0100 | [diff] [blame] | 65 | } |
| 66 | |
Robert Swiecki | 21eec51 | 2018-02-21 18:44:47 +0100 | [diff] [blame] | 67 | static bool showDisplay = true; |
Robert Swiecki | 98e2337 | 2019-01-30 11:50:18 +0100 | [diff] [blame] | 68 | static void sigHandler(int sig) { |
Robert Swiecki | 1c9d809 | 2017-06-01 02:39:09 +0200 | [diff] [blame] | 69 | /* We should not terminate upon SIGALRM delivery */ |
| 70 | if (sig == SIGALRM) { |
Robert Swiecki | 0dde76d | 2017-11-16 19:25:44 +0100 | [diff] [blame] | 71 | if (fuzz_shouldTerminate()) { |
| 72 | exitWithMsg("Terminating forcefully\n", EXIT_FAILURE); |
Robert Swiecki | 35978ac | 2017-11-16 18:00:53 +0100 | [diff] [blame] | 73 | } |
Robert Swiecki | 21eec51 | 2018-02-21 18:44:47 +0100 | [diff] [blame] | 74 | showDisplay = true; |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 75 | return; |
| 76 | } |
Robert Swiecki | 91a61ec | 2019-02-10 11:52:28 +0100 | [diff] [blame] | 77 | /* Do nothing with pings from the main thread */ |
| 78 | if (sig == SIGUSR1) { |
| 79 | return; |
| 80 | } |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 81 | /* It's handled in the signal thread */ |
| 82 | if (sig == SIGCHLD) { |
| 83 | return; |
| 84 | } |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 85 | |
Robert Swiecki | 8d01b01 | 2017-02-19 15:48:11 +0100 | [diff] [blame] | 86 | if (ATOMIC_GET(sigReceived) != 0) { |
Robert Swiecki | 35978ac | 2017-11-16 18:00:53 +0100 | [diff] [blame] | 87 | exitWithMsg("Repeated termination signal caugth\n", EXIT_FAILURE); |
Robert Swiecki | 8d01b01 | 2017-02-19 15:48:11 +0100 | [diff] [blame] | 88 | } |
| 89 | |
| 90 | ATOMIC_SET(sigReceived, sig); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 91 | } |
| 92 | |
Robert Swiecki | 087ff53 | 2018-01-16 22:28:07 +0100 | [diff] [blame] | 93 | static void setupRLimits(void) { |
| 94 | struct rlimit rlim; |
| 95 | if (getrlimit(RLIMIT_NOFILE, &rlim) == -1) { |
| 96 | PLOG_W("getrlimit(RLIMIT_NOFILE)"); |
| 97 | return; |
| 98 | } |
| 99 | if (rlim.rlim_cur >= 1024) { |
| 100 | return; |
| 101 | } |
| 102 | if (rlim.rlim_max < 1024) { |
Robert Swiecki | 1496069 | 2018-02-22 03:15:41 +0100 | [diff] [blame] | 103 | LOG_E("RLIMIT_NOFILE max limit < 1024 (%zu). Expect troubles!", (size_t)rlim.rlim_max); |
Robert Swiecki | 087ff53 | 2018-01-16 22:28:07 +0100 | [diff] [blame] | 104 | return; |
| 105 | } |
Robert Swiecki | df02b9d | 2018-02-21 21:20:13 +0100 | [diff] [blame] | 106 | rlim.rlim_cur = MIN(1024, rlim.rlim_max); // we don't need more |
Robert Swiecki | 087ff53 | 2018-01-16 22:28:07 +0100 | [diff] [blame] | 107 | if (setrlimit(RLIMIT_NOFILE, &rlim) == -1) { |
Robert Swiecki | 6a2fa64 | 2018-02-22 17:28:34 +0100 | [diff] [blame] | 108 | PLOG_E("Couldn't setrlimit(RLIMIT_NOFILE, cur=%zu/max=%zu)", (size_t)rlim.rlim_cur, |
| 109 | (size_t)rlim.rlim_max); |
Robert Swiecki | 087ff53 | 2018-01-16 22:28:07 +0100 | [diff] [blame] | 110 | } |
| 111 | } |
| 112 | |
Robert Swiecki | dc8047c | 2018-01-07 21:18:26 +0100 | [diff] [blame] | 113 | static void setupMainThreadTimer(void) { |
| 114 | const struct itimerval it = { |
Robert Swiecki | 7cd3f1e | 2019-02-12 08:25:22 +0100 | [diff] [blame] | 115 | .it_value = |
| 116 | { |
| 117 | .tv_sec = 1, |
| 118 | .tv_usec = 0, |
| 119 | }, |
| 120 | .it_interval = |
| 121 | { |
| 122 | .tv_sec = 0, |
| 123 | .tv_usec = 1000ULL * 200ULL, |
| 124 | }, |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 125 | }; |
| 126 | if (setitimer(ITIMER_REAL, &it, NULL) == -1) { |
| 127 | PLOG_F("setitimer(ITIMER_REAL)"); |
| 128 | } |
| 129 | } |
| 130 | |
Robert Swiecki | dc8047c | 2018-01-07 21:18:26 +0100 | [diff] [blame] | 131 | static void setupSignalsPreThreads(void) { |
Jagger | fbd4ae1 | 2016-09-02 02:26:02 +0200 | [diff] [blame] | 132 | /* Block signals which should be handled or blocked in the main thread */ |
Jagger | 33cce5d | 2016-04-16 20:10:36 +0200 | [diff] [blame] | 133 | sigset_t ss; |
Jagger | 090de22 | 2016-04-16 20:05:13 +0200 | [diff] [blame] | 134 | sigemptyset(&ss); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 135 | sigaddset(&ss, SIGTERM); |
| 136 | sigaddset(&ss, SIGINT); |
| 137 | sigaddset(&ss, SIGQUIT); |
Jagger | 33cce5d | 2016-04-16 20:10:36 +0200 | [diff] [blame] | 138 | sigaddset(&ss, SIGALRM); |
Jagger | ac75f26 | 2016-08-20 12:38:20 +0200 | [diff] [blame] | 139 | sigaddset(&ss, SIGPIPE); |
Robert Swiecki | 7cd3f1e | 2019-02-12 08:25:22 +0100 | [diff] [blame] | 140 | /* Linux/arch uses it to discover events from persistent fuzzing processes */ |
Jagger | fbd4ae1 | 2016-09-02 02:26:02 +0200 | [diff] [blame] | 141 | sigaddset(&ss, SIGIO); |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 142 | /* Let the signal thread catch SIGCHLD */ |
Robert Swiecki | dacf91a | 2019-02-11 15:09:16 +0100 | [diff] [blame] | 143 | sigaddset(&ss, SIGCHLD); |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 144 | /* This is checked for via sigwaitinfo/sigtimedwait */ |
| 145 | sigaddset(&ss, SIGUSR1); |
Robert Swiecki | 198ea70 | 2019-02-11 22:10:00 +0100 | [diff] [blame] | 146 | if (sigprocmask(SIG_SETMASK, &ss, NULL) != 0) { |
| 147 | PLOG_F("pthread_sigmask(SIG_SETMASK)"); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 148 | } |
| 149 | |
| 150 | struct sigaction sa = { |
| 151 | .sa_handler = sigHandler, |
| 152 | .sa_flags = 0, |
| 153 | }; |
| 154 | sigemptyset(&sa.sa_mask); |
| 155 | if (sigaction(SIGTERM, &sa, NULL) == -1) { |
| 156 | PLOG_F("sigaction(SIGTERM) failed"); |
| 157 | } |
| 158 | if (sigaction(SIGINT, &sa, NULL) == -1) { |
| 159 | PLOG_F("sigaction(SIGINT) failed"); |
| 160 | } |
| 161 | if (sigaction(SIGQUIT, &sa, NULL) == -1) { |
| 162 | PLOG_F("sigaction(SIGQUIT) failed"); |
| 163 | } |
Jagger | 33cce5d | 2016-04-16 20:10:36 +0200 | [diff] [blame] | 164 | if (sigaction(SIGALRM, &sa, NULL) == -1) { |
| 165 | PLOG_F("sigaction(SIGQUIT) failed"); |
| 166 | } |
Robert Swiecki | 91a61ec | 2019-02-10 11:52:28 +0100 | [diff] [blame] | 167 | if (sigaction(SIGUSR1, &sa, NULL) == -1) { |
| 168 | PLOG_F("sigaction(SIGUSR1) failed"); |
| 169 | } |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 170 | if (sigaction(SIGCHLD, &sa, NULL) == -1) { |
| 171 | PLOG_F("sigaction(SIGCHLD) failed"); |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | static void setupSignalsMainThread(void) { |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 176 | /* Unblock signals which should be handled by the main thread */ |
| 177 | sigset_t ss; |
| 178 | sigemptyset(&ss); |
| 179 | sigaddset(&ss, SIGTERM); |
| 180 | sigaddset(&ss, SIGINT); |
| 181 | sigaddset(&ss, SIGQUIT); |
Jagger | 3846dfc | 2016-04-16 20:06:16 +0200 | [diff] [blame] | 182 | sigaddset(&ss, SIGALRM); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 183 | if (sigprocmask(SIG_UNBLOCK, &ss, NULL) != 0) { |
Jagger | 33cce5d | 2016-04-16 20:10:36 +0200 | [diff] [blame] | 184 | PLOG_F("pthread_sigmask(SIG_UNBLOCK)"); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 185 | } |
| 186 | } |
| 187 | |
Robert Swiecki | 42b5d0c | 2018-07-26 15:12:29 +0200 | [diff] [blame] | 188 | static void printSummary(honggfuzz_t* hfuzz) { |
| 189 | uint64_t exec_per_sec = 0; |
| 190 | uint64_t elapsed_sec = time(NULL) - hfuzz->timing.timeStart; |
| 191 | if (elapsed_sec) { |
| 192 | exec_per_sec = hfuzz->cnts.mutationsCnt / elapsed_sec; |
| 193 | } |
| 194 | LOG_I("Summary iterations:%zu time:%" PRIu64 " speed:%" PRIu64, hfuzz->cnts.mutationsCnt, |
| 195 | elapsed_sec, exec_per_sec); |
| 196 | } |
| 197 | |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 198 | static void pingThreads(honggfuzz_t* hfuzz) { |
Robert Swiecki | dacf91a | 2019-02-11 15:09:16 +0100 | [diff] [blame] | 199 | for (size_t i = 0; i < hfuzz->threads.threadsMax; i++) { |
Robert Swiecki | 66fc573 | 2019-02-15 01:56:55 +0100 | [diff] [blame] | 200 | if (pthread_kill(hfuzz->threads.threads[i], SIGUSR1) != 0 && errno != EINTR) { |
Robert Swiecki | dacf91a | 2019-02-11 15:09:16 +0100 | [diff] [blame] | 201 | PLOG_W("pthread_kill(thread=%zu, SIGUSR1)", i); |
| 202 | } |
| 203 | } |
| 204 | } |
| 205 | |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 206 | static void* signalThread(void* arg) { |
| 207 | honggfuzz_t* hfuzz = (honggfuzz_t*)arg; |
| 208 | |
| 209 | sigset_t ss; |
| 210 | sigemptyset(&ss); |
| 211 | sigaddset(&ss, SIGCHLD); |
| 212 | if (pthread_sigmask(SIG_UNBLOCK, &ss, NULL) != 0) { |
| 213 | PLOG_F("Couldn't unblock SIGCHLD in the signal thread"); |
| 214 | } |
| 215 | |
| 216 | for (;;) { |
Robert Swiecki | 4a8dbbe | 2019-02-14 23:16:32 +0100 | [diff] [blame] | 217 | int sig; |
Robert Swiecki | 66fc573 | 2019-02-15 01:56:55 +0100 | [diff] [blame] | 218 | if (sigwait(&ss, &sig) != 0 && errno != EINTR) { |
Robert Swiecki | 4a8dbbe | 2019-02-14 23:16:32 +0100 | [diff] [blame] | 219 | PLOG_F("sigwait(SIGCHLD)"); |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 220 | } |
| 221 | if (fuzz_isTerminating()) { |
| 222 | break; |
| 223 | } |
Robert Swiecki | 66fc573 | 2019-02-15 01:56:55 +0100 | [diff] [blame] | 224 | if (sig == SIGCHLD) { |
| 225 | pingThreads(hfuzz); |
| 226 | } |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 227 | } |
| 228 | |
| 229 | return NULL; |
| 230 | } |
| 231 | |
Robert Swiecki | d50ed42 | 2017-11-13 23:32:26 +0100 | [diff] [blame] | 232 | int main(int argc, char** argv) { |
Robert Swiecki | c6a48b1 | 2016-03-11 17:41:57 +0100 | [diff] [blame] | 233 | /* |
| 234 | * Work around CygWin/MinGW |
| 235 | */ |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 236 | char** myargs = (char**)util_Malloc(sizeof(char*) * (argc + 1)); |
Robert Swiecki | 3ab1664 | 2018-01-12 18:08:37 +0100 | [diff] [blame] | 237 | defer { |
| 238 | free(myargs); |
| 239 | }; |
Jagger | 1ebc6dc | 2016-03-12 01:39:09 +0100 | [diff] [blame] | 240 | |
| 241 | int i; |
| 242 | for (i = 0U; i < argc; i++) { |
Robert Swiecki | c6a48b1 | 2016-03-11 17:41:57 +0100 | [diff] [blame] | 243 | myargs[i] = argv[i]; |
| 244 | } |
| 245 | myargs[i] = NULL; |
| 246 | |
| 247 | if (cmdlineParse(argc, myargs, &hfuzz) == false) { |
Robert Swiecki | c8c32db | 2015-10-09 18:06:22 +0200 | [diff] [blame] | 248 | LOG_F("Parsing of the cmd-line arguments failed"); |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 249 | } |
| 250 | |
Robert Swiecki | 5e26bd9 | 2018-03-02 12:09:34 +0100 | [diff] [blame] | 251 | if (hfuzz.display.useScreen) { |
Robert Swiecki | 1f1ce17 | 2017-02-10 03:43:00 +0100 | [diff] [blame] | 252 | display_init(); |
| 253 | } |
| 254 | |
Robert Swiecki | 5e26bd9 | 2018-03-02 12:09:34 +0100 | [diff] [blame] | 255 | if (hfuzz.socketFuzzer.enabled) { |
Robert Swiecki | 98e2337 | 2019-01-30 11:50:18 +0100 | [diff] [blame] | 256 | LOG_I("No input file corpus loaded, the external socket_fuzzer is responsible for " |
| 257 | "creating the fuzz data"); |
dobin | edf9f8d | 2018-01-21 13:57:02 +0100 | [diff] [blame] | 258 | setupSocketFuzzer(&hfuzz); |
| 259 | } else if (!input_init(&hfuzz)) { |
Robert Swiecki | ced3eba | 2017-12-15 15:33:03 +0100 | [diff] [blame] | 260 | LOG_F("Couldn't load input corpus"); |
| 261 | exit(EXIT_FAILURE); |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 262 | } |
| 263 | |
Robert Swiecki | 04dcac3 | 2018-03-02 03:05:26 +0100 | [diff] [blame] | 264 | if (hfuzz.mutate.dictionaryFile && (input_parseDictionary(&hfuzz) == false)) { |
| 265 | LOG_F("Couldn't parse dictionary file ('%s')", hfuzz.mutate.dictionaryFile); |
robert.swiecki@gmail.com | 4f1124f | 2015-04-21 17:12:22 +0000 | [diff] [blame] | 266 | } |
| 267 | |
Robert Swiecki | a5b918a | 2018-03-07 23:59:53 +0100 | [diff] [blame] | 268 | if (hfuzz.feedback.blacklistFile && (input_parseBlacklist(&hfuzz) == false)) { |
| 269 | LOG_F("Couldn't parse stackhash blacklist file ('%s')", hfuzz.feedback.blacklistFile); |
Anestis Bechtsoudis | d59af69 | 2015-09-21 15:15:05 +0300 | [diff] [blame] | 270 | } |
Anestis Bechtsoudis | 00be189 | 2016-10-31 09:29:44 +0200 | [diff] [blame] | 271 | #define hfuzzl hfuzz.linux |
Robert Swiecki | d50ed42 | 2017-11-13 23:32:26 +0100 | [diff] [blame] | 272 | if (hfuzzl.symsBlFile && |
| 273 | ((hfuzzl.symsBlCnt = files_parseSymbolFilter(hfuzzl.symsBlFile, &hfuzzl.symsBl)) == 0)) { |
Anestis Bechtsoudis | 3dce6ac | 2016-10-31 08:51:14 +0200 | [diff] [blame] | 274 | LOG_F("Couldn't parse symbols blacklist file ('%s')", hfuzzl.symsBlFile); |
Anestis Bechtsoudis | ba68b38 | 2016-10-29 20:44:15 +0300 | [diff] [blame] | 275 | } |
| 276 | |
Robert Swiecki | d50ed42 | 2017-11-13 23:32:26 +0100 | [diff] [blame] | 277 | if (hfuzzl.symsWlFile && |
| 278 | ((hfuzzl.symsWlCnt = files_parseSymbolFilter(hfuzzl.symsWlFile, &hfuzzl.symsWl)) == 0)) { |
Anestis Bechtsoudis | 3dce6ac | 2016-10-31 08:51:14 +0200 | [diff] [blame] | 279 | LOG_F("Couldn't parse symbols whitelist file ('%s')", hfuzzl.symsWlFile); |
Anestis Bechtsoudis | ba68b38 | 2016-10-29 20:44:15 +0300 | [diff] [blame] | 280 | } |
Anestis Bechtsoudis | 00be189 | 2016-10-31 09:29:44 +0200 | [diff] [blame] | 281 | |
Robert Swiecki | a5b918a | 2018-03-07 23:59:53 +0100 | [diff] [blame] | 282 | if (hfuzz.feedback.dynFileMethod != _HF_DYNFILE_NONE) { |
| 283 | if (!(hfuzz.feedback.feedbackMap = files_mapSharedMem( |
| 284 | sizeof(feedback_t), &hfuzz.feedback.bbFd, "hfuzz-feedback", hfuzz.io.workDir))) { |
Robert Swiecki | 82c707c | 2017-11-14 16:36:23 +0100 | [diff] [blame] | 285 | LOG_F("files_mapSharedMem(sz=%zu, dir='%s') failed", sizeof(feedback_t), |
| 286 | hfuzz.io.workDir); |
Robert Swiecki | e4d63d4 | 2016-11-01 00:40:51 +0100 | [diff] [blame] | 287 | } |
| 288 | } |
| 289 | |
Robert Swiecki | 087ff53 | 2018-01-16 22:28:07 +0100 | [diff] [blame] | 290 | setupRLimits(); |
Robert Swiecki | dc8047c | 2018-01-07 21:18:26 +0100 | [diff] [blame] | 291 | setupSignalsPreThreads(); |
Robert Swiecki | 64d5243 | 2019-02-14 23:02:13 +0100 | [diff] [blame] | 292 | fuzz_threadsStart(&hfuzz); |
| 293 | |
| 294 | pthread_t sigthread; |
| 295 | if (!subproc_runThread(&hfuzz, &sigthread, signalThread)) { |
| 296 | LOG_F("Couldn't start the signal thread"); |
| 297 | } |
| 298 | |
Robert Swiecki | dc8047c | 2018-01-07 21:18:26 +0100 | [diff] [blame] | 299 | setupSignalsMainThread(); |
Robert Swiecki | dc8047c | 2018-01-07 21:18:26 +0100 | [diff] [blame] | 300 | setupMainThreadTimer(); |
| 301 | |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 302 | for (;;) { |
Robert Swiecki | 5e26bd9 | 2018-03-02 12:09:34 +0100 | [diff] [blame] | 303 | if (hfuzz.display.useScreen && showDisplay) { |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 304 | display_display(&hfuzz); |
Robert Swiecki | 21eec51 | 2018-02-21 18:44:47 +0100 | [diff] [blame] | 305 | showDisplay = false; |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 306 | } |
Robert Swiecki | 8d01b01 | 2017-02-19 15:48:11 +0100 | [diff] [blame] | 307 | if (ATOMIC_GET(sigReceived) > 0) { |
Robert Swiecki | c95cf2a | 2017-06-23 15:31:08 +0200 | [diff] [blame] | 308 | LOG_I("Signal %d (%s) received, terminating", ATOMIC_GET(sigReceived), |
Robert Swiecki | 4e595fb | 2017-10-11 17:26:51 +0200 | [diff] [blame] | 309 | strsignal(ATOMIC_GET(sigReceived))); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 310 | break; |
| 311 | } |
Robert Swiecki | 66b6512 | 2017-11-11 02:55:55 +0100 | [diff] [blame] | 312 | if (ATOMIC_GET(hfuzz.threads.threadsFinished) >= hfuzz.threads.threadsMax) { |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 313 | break; |
| 314 | } |
Robert Swiecki | 371e129 | 2017-12-18 01:10:33 +0100 | [diff] [blame] | 315 | if (hfuzz.timing.runEndTime > 0 && (time(NULL) > hfuzz.timing.runEndTime)) { |
Robert Swiecki | c95cf2a | 2017-06-23 15:31:08 +0200 | [diff] [blame] | 316 | LOG_I("Maximum run time reached, terminating"); |
Robert Swiecki | c95cf2a | 2017-06-23 15:31:08 +0200 | [diff] [blame] | 317 | break; |
| 318 | } |
Robert Swiecki | 387b79a | 2019-02-14 23:20:52 +0100 | [diff] [blame] | 319 | pingThreads(&hfuzz); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 320 | pause(); |
| 321 | } |
| 322 | |
Robert Swiecki | 0dde76d | 2017-11-16 19:25:44 +0100 | [diff] [blame] | 323 | fuzz_setTerminating(); |
Robert Swiecki | dacf91a | 2019-02-11 15:09:16 +0100 | [diff] [blame] | 324 | |
Robert Swiecki | acdf0bd | 2019-02-17 02:42:04 +0100 | [diff] [blame] | 325 | for (;;) { |
| 326 | if (ATOMIC_GET(hfuzz.threads.threadsFinished) >= hfuzz.threads.threadsMax) { |
| 327 | break; |
| 328 | } |
| 329 | pingThreads(&hfuzz); |
| 330 | usleep(50000); /* 50ms */ |
| 331 | } |
Robert Swiecki | 33fb284 | 2017-02-19 05:39:50 +0100 | [diff] [blame] | 332 | |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 333 | /* Clean-up global buffers */ |
Robert Swiecki | a5b918a | 2018-03-07 23:59:53 +0100 | [diff] [blame] | 334 | if (hfuzz.feedback.blacklist) { |
| 335 | free(hfuzz.feedback.blacklist); |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 336 | } |
Kamil Rytarowski | bdfe2a7 | 2018-08-18 12:28:29 +0200 | [diff] [blame] | 337 | #if defined(_HF_ARCH_LINUX) |
Anestis Bechtsoudis | ba68b38 | 2016-10-29 20:44:15 +0300 | [diff] [blame] | 338 | if (hfuzz.linux.symsBl) { |
| 339 | free(hfuzz.linux.symsBl); |
| 340 | } |
| 341 | if (hfuzz.linux.symsWl) { |
| 342 | free(hfuzz.linux.symsWl); |
| 343 | } |
Kamil Rytarowski | bdfe2a7 | 2018-08-18 12:28:29 +0200 | [diff] [blame] | 344 | #elif defined(_HF_ARCH_NETBSD) |
| 345 | if (hfuzz.netbsd.symsBl) { |
| 346 | free(hfuzz.netbsd.symsBl); |
| 347 | } |
| 348 | if (hfuzz.netbsd.symsWl) { |
| 349 | free(hfuzz.netbsd.symsWl); |
| 350 | } |
| 351 | #endif |
Robert Swiecki | 5e26bd9 | 2018-03-02 12:09:34 +0100 | [diff] [blame] | 352 | if (hfuzz.socketFuzzer.enabled) { |
dobin | edf9f8d | 2018-01-21 13:57:02 +0100 | [diff] [blame] | 353 | cleanupSocketFuzzer(); |
| 354 | } |
Jagger | 08816fd | 2016-03-11 01:32:38 +0100 | [diff] [blame] | 355 | |
Robert Swiecki | 42b5d0c | 2018-07-26 15:12:29 +0200 | [diff] [blame] | 356 | printSummary(&hfuzz); |
Robert Swiecki | 19a08e3 | 2018-07-26 02:07:52 +0200 | [diff] [blame] | 357 | |
Robert Swiecki | 37778e0 | 2016-03-15 15:45:28 +0100 | [diff] [blame] | 358 | return EXIT_SUCCESS; |
robert.swiecki | 3bb518c | 2010-10-14 00:48:24 +0000 | [diff] [blame] | 359 | } |