Prevents child processes from inheriting all open inheritable handles. This commonly happens when multiple threads are creating processes simultaneously.
Uses the proper API on Windows >= Vista or a lock for older versions.
* Kill the thread only if is alive.
* Remove rz_th_lock_guard.
* Use rz_sys_usleep since pthread_yield/sched_yield are not portable.
* Kill threads only on error.
* Avoid killing already-dead threads.
* RzThreadFunction now returns void* and added test_thread_queue.
* Removed pthread_exit
The stdin_fd may be -1 whenever a subprocess does not have its stdin piped.
This appeared as a failed assertion on Mac OS X 10.5, where rz_sys_pipe_close()
uses a hashtable to track fds.
* Create `rz_windows.h`
* Move `RzThread` structure definitions to internal header
* Create and use `rz_th_get_user()` API to avoid exposing `RzThread` layout in external header
* Make `rz_th_self()` an IPI
* Use `_wmkdir()` in `rz_sys_mkdir()` on Windows
* Remove unused `winkd_break_read` function
* Remove `RzIORap` definition from `rz_io.h`
* Remove include of `Windows.h` from `rz_types.h`
* Use `rz_windows.h` when necessary
* Remove `RzCoreRtrHost` definition from `rz_core.h`
* Remove `rz_socket.h` include from `rz_core.h`
* Use wide version of Windows APIs in subprocess functions
* Use `wmain` on Windows to get UTF16 arguments
* Use wide version of APIs in `rz_cons`
* Always try to set console codepage to UTF8
Co-authored-by: Riccardo Schirone <ret2libc@users.noreply.github.com>
* Do not use setenv after fork, it's not async-signal-safe
* Do not use mutexes after fork
If pipe2 is not available on a system, we try to simulate the atomic
setting of O_CLOEXEC in different ways (depending on whether O_CLOEXEC
is at least available or not). However this involves using mutexes. When
forking, only the calling thread is forked, so it is important to lock
the mutex before the fork. However, in the child between the fork and
the exec* it is recommended to use only async-signal-safe functions. mutex
operations are not async-signal-safe, so we just keep track of whether we are
in the child or not and avoid using the mutex as necessary.
* Replace pthread_atfork with rz_sys_fork
By default, pipes file descriptors are not closed on exec. This means
they are inherited by the child process. However, this may be a problem
in particular in multi-threading programs (e.g. rz-test), because EOF is
not sent to a pipe until the last pipe file descriptor is closed.
This commit makes sure that by default pipes are created with O_CLOEXEC,
so they are closed whenever an exec syscall is executed. Usually pipe
file descriptors are duplicated to be stdin/stdout/stderr of the
children process and those dupped file descriptors won't be closed on
exec.
In case pipe2 is not available (e.g. MacOS), we do a pipe + fcntl, which
is in theory racy (see man open(2)). For this reason pipe, exec, system,
etc. are wrapped in rz_sys and they use a global mutex to make sure a
pipe is either created and set as O_CLOEXEC or not created at all before
an exec operation is done.
On very old systems, O_CLOEXEC may not be available at all. In those
cases, which should be rare, we just keep a list of file descriptors
created with rz_sys_pipe that we need to close before executing another
process.
Interaction with external libs may be tricky. We expect external libs to
create files/pipes that need to be closed on exec with the right flags
and we expect rizin code to manually close pipes file descriptors as
appropriate if the exec syscall is executed by an external library
(non-rizin code).
Make sure execl is found by acr/make
