Revision control
Copy as Markdown
// Copyright (C) 2016 The Qt Company Ltd.
// Copyright (C) 2016 Intel Corporation.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
// Qt-Security score:significant reason:default
#ifndef QCORE_UNIX_P_H
#define QCORE_UNIX_P_H
//
// W A R N I N G
// -------------
//
// This file is not part of the Qt API. It exists for the convenience
// of Qt code on Unix. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
//
#include "qplatformdefs.h"
#include <QtCore/private/qglobal_p.h>
#include "qbytearray.h"
#include "qdeadlinetimer.h"
#ifndef Q_OS_UNIX
# error "qcore_unix_p.h included on a non-Unix system"
#endif
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#if !defined (Q_OS_VXWORKS)
# if !defined(Q_OS_HPUX) || defined(__ia64)
# include <sys/select.h>
# endif
# include <sys/time.h>
#else
# include <selectLib.h>
#endif
#include <chrono>
#include <sys/wait.h>
#include <errno.h>
#include <fcntl.h>
#if defined(Q_OS_VXWORKS)
# include <ioLib.h>
#endif
#ifdef QT_NO_NATIVE_POLL
# include "qpoll_p.h"
#else
# include <poll.h>
#endif
struct sockaddr;
#define QT_EINTR_LOOP(var, cmd) \
do { \
var = cmd; \
} while (var == -1 && errno == EINTR)
QT_BEGIN_NAMESPACE
Q_DECLARE_TYPEINFO(pollfd, Q_PRIMITIVE_TYPE);
static inline constexpr clockid_t QSteadyClockClockId =
#if !defined(CLOCK_MONOTONIC)
// we don't know how to set the monotonic clock
CLOCK_REALTIME
#elif defined(_LIBCPP_VERSION) \
&& (defined(_LIBCPP_HAS_NO_MONOTONIC_CLOCK) \
|| (defined(_LIBCPP_HAS_MONOTONIC_CLOCK) && !_LIBCPP_HAS_MONOTONIC_CLOCK))
// libc++ falling back to system_clock (the macro was inverted in LLVM 20)
CLOCK_REALTIME
#elif defined(__GLIBCXX__) && !defined(_GLIBCXX_USE_CLOCK_MONOTONIC)
// libstdc++ falling back to system_clock
CLOCK_REALTIME
#elif defined(_LIBCPP_VERSION) && defined(Q_OS_DARWIN)
// on Apple systems, libc++ uses CLOCK_MONOTONIC_RAW since LLVM 11
CLOCK_MONOTONIC_RAW
#elif defined(__GLIBCXX__) || defined(_LIBCPP_VERSION)
// both libstdc++ and libc++ otherwise use CLOCK_MONOTONIC
CLOCK_MONOTONIC
#else
# warning "Unknown C++ Standard Library implementation - code may be sub-optimal"
CLOCK_REALTIME
#endif
;
static inline constexpr clockid_t QWaitConditionClockId =
#if !QT_CONFIG(thread)
// bootstrap mode, there are no wait conditions
CLOCK_REALTIME
#elif !QT_CONFIG(pthread_condattr_setclock)
// OSes that lack pthread_condattr_setclock() (e.g., Darwin)
CLOCK_REALTIME
#elif defined(Q_OS_QNX)
// unknown why use of the monotonic clock causes failures
CLOCK_REALTIME
#else
QSteadyClockClockId;
#endif
;
static constexpr auto OneSecAsNsecs = std::chrono::nanoseconds(std::chrono::seconds{ 1 }).count();
inline timespec durationToTimespec(std::chrono::nanoseconds timeout) noexcept
{
using namespace std::chrono;
const seconds secs = duration_cast<seconds>(timeout);
const nanoseconds frac = timeout - secs;
struct timespec ts;
ts.tv_sec = secs.count();
ts.tv_nsec = frac.count();
return ts;
}
template <typename Duration>
inline Duration timespecToChrono(timespec ts) noexcept
{
using namespace std::chrono;
return duration_cast<Duration>(seconds{ts.tv_sec} + nanoseconds{ts.tv_nsec});
}
// Internal operator functions for timespecs
constexpr inline timespec &normalizedTimespec(timespec &t)
{
while (t.tv_nsec >= OneSecAsNsecs) {
++t.tv_sec;
t.tv_nsec -= OneSecAsNsecs;
}
while (t.tv_nsec < 0) {
--t.tv_sec;
t.tv_nsec += OneSecAsNsecs;
}
return t;
}
inline timeval timespecToTimeval(timespec ts)
{
timeval tv;
tv.tv_sec = ts.tv_sec;
tv.tv_usec = ts.tv_nsec / 1000;
return tv;
}
template <clockid_t ClockId = QSteadyClockClockId>
inline timespec deadlineToAbstime(QDeadlineTimer deadline)
{
using namespace std::chrono;
using Clock =
std::conditional_t<ClockId == CLOCK_REALTIME, system_clock, steady_clock>;
auto timePoint = deadline.deadline<Clock>();
if (timePoint < typename Clock::time_point{})
return {};
return durationToTimespec(timePoint.time_since_epoch());
}
Q_CORE_EXPORT void qt_ignore_sigpipe() noexcept;
#if defined(Q_PROCESSOR_X86_32) && defined(__GLIBC__)
# if !__GLIBC_PREREQ(2, 22)
Q_CORE_EXPORT int qt_open64(const char *pathname, int flags, mode_t);
# undef QT_OPEN
# define QT_OPEN qt_open64
# endif
#endif
#ifdef AT_FDCWD
static inline int qt_safe_openat(int dfd, const char *pathname, int flags, mode_t mode = 0777)
{
// everyone already has O_CLOEXEC
int fd;
QT_EINTR_LOOP(fd, openat(dfd, pathname, flags | O_CLOEXEC, mode));
return fd;
}
#endif
// don't call QT_OPEN or ::open
// call qt_safe_open
static inline int qt_safe_open(const char *pathname, int flags, mode_t mode = 0777)
{
#ifdef O_CLOEXEC
flags |= O_CLOEXEC;
#endif
int fd;
QT_EINTR_LOOP(fd, QT_OPEN(pathname, flags, mode));
#ifndef O_CLOEXEC
if (fd != -1)
::fcntl(fd, F_SETFD, FD_CLOEXEC);
#endif
return fd;
}
#undef QT_OPEN
#define QT_OPEN qt_safe_open
// don't call ::pipe
// call qt_safe_pipe
static inline int qt_safe_pipe(int pipefd[2], int flags = 0)
{
Q_ASSERT((flags & ~O_NONBLOCK) == 0);
#ifdef QT_THREADSAFE_CLOEXEC
// use pipe2
flags |= O_CLOEXEC;
return ::pipe2(pipefd, flags); // pipe2 is documented not to return EINTR
#else
int ret = ::pipe(pipefd);
if (ret == -1)
return -1;
::fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
::fcntl(pipefd[1], F_SETFD, FD_CLOEXEC);
// set non-block too?
if (flags & O_NONBLOCK) {
::fcntl(pipefd[0], F_SETFL, ::fcntl(pipefd[0], F_GETFL) | O_NONBLOCK);
::fcntl(pipefd[1], F_SETFL, ::fcntl(pipefd[1], F_GETFL) | O_NONBLOCK);
}
return 0;
#endif
}
// don't call dup or fcntl(F_DUPFD)
static inline int qt_safe_dup(int oldfd, int atleast = 0, int flags = FD_CLOEXEC)
{
Q_ASSERT(flags == FD_CLOEXEC || flags == 0);
#ifdef F_DUPFD_CLOEXEC
int cmd = F_DUPFD;
if (flags & FD_CLOEXEC)
cmd = F_DUPFD_CLOEXEC;
return ::fcntl(oldfd, cmd, atleast);
#else
// use F_DUPFD
int ret = ::fcntl(oldfd, F_DUPFD, atleast);
if (flags && ret != -1)
::fcntl(ret, F_SETFD, flags);
return ret;
#endif
}
// don't call dup2
// call qt_safe_dup2
static inline int qt_safe_dup2(int oldfd, int newfd, int flags = FD_CLOEXEC)
{
Q_ASSERT(flags == FD_CLOEXEC || flags == 0);
int ret;
#if QT_CONFIG(dup3)
// use dup3
QT_EINTR_LOOP(ret, ::dup3(oldfd, newfd, flags ? O_CLOEXEC : 0));
return ret;
#else
QT_EINTR_LOOP(ret, ::dup2(oldfd, newfd));
if (ret == -1)
return -1;
if (flags)
::fcntl(newfd, F_SETFD, flags);
return 0;
#endif
}
static inline qint64 qt_safe_read(int fd, void *data, qint64 maxlen)
{
qint64 ret = 0;
QT_EINTR_LOOP(ret, QT_READ(fd, data, maxlen));
return ret;
}
#undef QT_READ
#define QT_READ qt_safe_read
static inline qint64 qt_safe_write(int fd, const void *data, qint64 len)
{
qint64 ret = 0;
QT_EINTR_LOOP(ret, QT_WRITE(fd, data, len));
return ret;
}
#undef QT_WRITE
#define QT_WRITE qt_safe_write
static inline qint64 qt_safe_write_nosignal(int fd, const void *data, qint64 len)
{
qt_ignore_sigpipe();
return qt_safe_write(fd, data, len);
}
static inline int qt_safe_close(int fd)
{
int ret;
QT_EINTR_LOOP(ret, QT_CLOSE(fd));
return ret;
}
#undef QT_CLOSE
#define QT_CLOSE qt_safe_close
// - VxWorks & iOS/tvOS/watchOS don't have processes
#if QT_CONFIG(process)
static inline int qt_safe_execve(const char *filename, char *const argv[],
char *const envp[])
{
int ret;
QT_EINTR_LOOP(ret, ::execve(filename, argv, envp));
return ret;
}
static inline int qt_safe_execv(const char *path, char *const argv[])
{
int ret;
QT_EINTR_LOOP(ret, ::execv(path, argv));
return ret;
}
static inline int qt_safe_execvp(const char *file, char *const argv[])
{
int ret;
QT_EINTR_LOOP(ret, ::execvp(file, argv));
return ret;
}
static inline pid_t qt_safe_waitpid(pid_t pid, int *status, int options)
{
int ret;
QT_EINTR_LOOP(ret, ::waitpid(pid, status, options));
return ret;
}
#endif // QT_CONFIG(process)
#if !defined(_POSIX_MONOTONIC_CLOCK)
# define _POSIX_MONOTONIC_CLOCK -1
#endif
QByteArray qt_readlink(const char *path);
/* non-static */
inline bool qt_haveLinuxProcfs()
{
#ifdef Q_OS_LINUX
# ifdef QT_LINUX_ALWAYS_HAVE_PROCFS
return true;
# else
static const bool present = (access("/proc/version", F_OK) == 0);
return present;
# endif
#else
return false;
#endif
}
Q_CORE_EXPORT int qt_safe_poll(struct pollfd *fds, nfds_t nfds, QDeadlineTimer deadline);
static inline struct pollfd qt_make_pollfd(int fd, short events)
{
struct pollfd pfd = { fd, events, 0 };
return pfd;
}
// according to X/OPEN we have to define semun ourselves
// we use prefix as on some systems sem.h will have it
struct semid_ds;
union qt_semun {
int val; /* value for SETVAL */
struct semid_ds *buf; /* buffer for IPC_STAT, IPC_SET */
unsigned short *array; /* array for GETALL, SETALL */
};
QT_END_NAMESPACE
#endif