ExternalVendorCode/AFLplusplus
1
0
Fork 0
mirror of https://github.com/AFLplusplus/AFLplusplus.git synced 2025-06-10 01:01:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

reverted extendended read_timed

Browse Source
This commit is contained in:
Dominik Maier 2020-05-30 13:53:00 +02:00
parent b16ccb4811
commit 95b46b4278
3 changed files with 26 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
include/common.h
View File

@ -107,9 +107,6 @@ u8 *u_stringify_mem_size(u8 *buf, u64 val);
u8 *u_stringify_time_diff(u8 *buf, u64 cur_ms, u64 event_ms); u8 *u_stringify_time_diff(u8 *buf, u64 cur_ms, u64 event_ms);
/* Sets a filedescriptor to non-blocking mode (for read_timed) */
void set_nonblocking(int fd);
/* Wrapper for select() and read(), reading exactly len bytes. /* Wrapper for select() and read(), reading exactly len bytes.
Returns the time passed to read. Returns the time passed to read.
stop_soon should point to a variable indicating ctrl+c was pressed. stop_soon should point to a variable indicating ctrl+c was pressed.

82
src/afl-common.c
View File

@ -39,7 +39,6 @@
#include <limits.h> #include <limits.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/ioctl.h>
#include <unistd.h> #include <unistd.h>
#include <fcntl.h> #include <fcntl.h>
@ -870,82 +869,51 @@ u8 *u_stringify_time_diff(u8 *buf, u64 cur_ms, u64 event_ms) {
} }
/* sets a FD to non-blocking mode (used for read_timed) */ /* Wrapper for select() and read(), reading len bytes.
void set_nonblocking(int fd) { Assumes that all bytes are available on read!
int ret = 0;
int opt = 1;
ret = ioctl(fd, FIONBIO, &opt);
if (ret == -1) { PFATAL("Could not enable non-blocking mode on fd %d", fd); }
}
/* Wrapper for select() and read(), reading exactly len bytes.
Should be called on non-blocking fds.
Returns the time passed to read. Returns the time passed to read.
If the wait times out, returns timeout_ms + 1; If the wait times out, returns timeout_ms + 1;
Returns 0 if an error occurred (fd closed, signal, ...); Returns 0 if an error occurred (fd closed, signal, ...); */
*/
u32 read_timed(s32 fd, void *buf, size_t len, u32 timeout_ms, u32 read_timed(s32 fd, void *buf, size_t len, u32 timeout_ms,
volatile u8 *stop_soon_p) { volatile u8 *stop_soon_p) {
struct timeval timeout;
fd_set readfds; fd_set readfds;
FD_ZERO(&readfds); FD_ZERO(&readfds);
FD_SET(fd, &readfds); FD_SET(fd, &readfds);
struct timeval timeout;
size_t read_total = 0; timeout.tv_sec = (timeout_ms / 1000);
ssize_t len_read = 0; timeout.tv_usec = (timeout_ms % 1000) * 1000;
#if !defined(__linux__)
u64 read_start = get_cur_time_us();
#endif
#if defined(__linux__) /* set exceptfds as well to return when a child exited/closed the pipe. */
timeout.tv_sec = (timeout_ms / 1000); int sret = select(fd + 1, &readfds, NULL, NULL, &timeout);
timeout.tv_usec = (timeout_ms % 1000) * 1000;
#else
u64 time_start = get_cur_time_us();
#endif
while (read_total < len) { if (!sret) {
#if !defined(__linux__) return timeout_ms + 1;
u64 time_current = get_cur_time_us();
u64 timeout_current = timeout_ms - (time_current - time_start);
timeout.tv_sec = (timeout_current / 1000);
timeout.tv_usec = (timeout_current % 1000) * 1000;
#endif
/* set exceptfds as well to return when a child exited/closed the pipe. */ } else if (sret < 0) {
int sret = select(fd + 1, &readfds, NULL, NULL, &timeout);
if (!sret) { return 0;
// printf("Timeout in sret.");
return timeout_ms + 1;
} else if (sret < 0) {
/* Retry select for all signals other than than ctrl+c */
if (errno == EINTR && !*stop_soon_p) { continue; }
return 0;
}
len_read = read(fd, ((u8 *)buf) + read_total, len - read_total);
if (len_read <= 0) { return 0; }
read_total += len_read;
} }
#if defined(__linux__) ssize_t len_read = read(fd, ((u8 *)buf), len);
s32 exec_ms = if (len_read < len) { return 0; }
#if defined(__linux__)
u32 exec_ms =
MIN(timeout_ms, MIN(timeout_ms,
((u64)timeout_ms - (timeout.tv_sec * 1000 + timeout.tv_usec / 1000))); ((u64)timeout_ms - (timeout.tv_sec * 1000 + timeout.tv_usec / 1000)));
#else #else
u32 exec_ms = get_cur_time_us() - time_start; u32 exec_ms = get_cur_time_us() - read_start;
#endif #endif
return exec_ms > 0 ? exec_ms // ensure to report 1 ms has passed (0 is an error)
: 1; // at least 1 milli must have passed (0 is an error) return exec_ms > 0 ? exec_ms : 1;
} }

3
src/afl-forkserver.c
View File

@ -401,8 +401,6 @@ void afl_fsrv_start(afl_forkserver_t *fsrv, char **argv,
fsrv->fsrv_ctl_fd = ctl_pipe[1]; fsrv->fsrv_ctl_fd = ctl_pipe[1];
fsrv->fsrv_st_fd = st_pipe[0]; fsrv->fsrv_st_fd = st_pipe[0];
set_nonblocking(fsrv->fsrv_st_fd);
/* Wait for the fork server to come up, but don't wait too long. */ /* Wait for the fork server to come up, but don't wait too long. */
rlen = 0; rlen = 0;
@ -857,6 +855,7 @@ fsrv_run_result_t afl_fsrv_run_target(afl_forkserver_t *fsrv, u32 timeout,
if ((res = read(fsrv->fsrv_st_fd, &fsrv->child_pid, 4)) != 4) { if ((res = read(fsrv->fsrv_st_fd, &fsrv->child_pid, 4)) != 4) {
if (*stop_soon_p) { return 0; }
RPFATAL(res, "Unable to request new process from fork server (OOM?)"); RPFATAL(res, "Unable to request new process from fork server (OOM?)");
} }