1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Copyright (C) 2016 Intel Corporation.
5 ** Contact: https://www.qt.io/licensing/
6 **
7 ** This file is part of the QtCore module of the Qt Toolkit.
8 **
9 ** $QT_BEGIN_LICENSE:LGPL$
10 ** Commercial License Usage
11 ** Licensees holding valid commercial Qt licenses may use this file in
12 ** accordance with the commercial license agreement provided with the
13 ** Software or, alternatively, in accordance with the terms contained in
14 ** a written agreement between you and The Qt Company. For licensing terms
15 ** and conditions see https://www.qt.io/terms-conditions. For further
16 ** information use the contact form at https://www.qt.io/contact-us.
17 **
18 ** GNU Lesser General Public License Usage
19 ** Alternatively, this file may be used under the terms of the GNU Lesser
20 ** General Public License version 3 as published by the Free Software
21 ** Foundation and appearing in the file LICENSE.LGPL3 included in the
22 ** packaging of this file. Please review the following information to
23 ** ensure the GNU Lesser General Public License version 3 requirements
24 ** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
25 **
26 ** GNU General Public License Usage
27 ** Alternatively, this file may be used under the terms of the GNU
28 ** General Public License version 2.0 or (at your option) the GNU General
29 ** Public license version 3 or any later version approved by the KDE Free
30 ** Qt Foundation. The licenses are as published by the Free Software
31 ** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
32 ** included in the packaging of this file. Please review the following
33 ** information to ensure the GNU General Public License requirements will
34 ** be met: https://www.gnu.org/licenses/gpl-2.0.html and
35 ** https://www.gnu.org/licenses/gpl-3.0.html.
36 **
37 ** $QT_END_LICENSE$
38 **
39 ****************************************************************************/
40 
41 #ifndef QCORE_UNIX_P_H
42 #define QCORE_UNIX_P_H
43 
44 //
45 //  W A R N I N G
46 //  -------------
47 //
48 // This file is not part of the Qt API.  It exists for the convenience
49 // of Qt code on Unix. This header file may change from version to
50 // version without notice, or even be removed.
51 //
52 // We mean it.
53 //
54 
55 #include "qplatformdefs.h"
56 #include <QtCore/private/qglobal_p.h>
57 #include "qatomic.h"
58 #include "qbytearray.h"
59 
60 #ifndef Q_OS_UNIX
61 # error "qcore_unix_p.h included on a non-Unix system"
62 #endif
63 
64 #include <string.h>
65 #include <sys/types.h>
66 #include <sys/stat.h>
67 #include <unistd.h>
68 
69 #ifdef Q_OS_NACL
70 #elif !defined (Q_OS_VXWORKS)
71 # if !defined(Q_OS_HPUX) || defined(__ia64)
72 #  include <sys/select.h>
73 # endif
74 #  include <sys/time.h>
75 #else
76 #  include <selectLib.h>
77 #endif
78 
79 #include <sys/wait.h>
80 #include <errno.h>
81 #include <fcntl.h>
82 
83 #if !defined(QT_POSIX_IPC) && !defined(QT_NO_SHAREDMEMORY) && !defined(Q_OS_ANDROID)
84 #  include <sys/ipc.h>
85 #endif
86 
87 #if defined(Q_OS_VXWORKS)
88 #  include <ioLib.h>
89 #endif
90 
91 #ifdef QT_NO_NATIVE_POLL
92 #  include "qpoll_p.h"
93 #else
94 #  include <poll.h>
95 #endif
96 
97 struct sockaddr;
98 
99 #define EINTR_LOOP(var, cmd)                    \
100     do {                                        \
101         var = cmd;                              \
102     } while (var == -1 && errno == EINTR)
103 
104 QT_BEGIN_NAMESPACE
105 
106 Q_DECLARE_TYPEINFO(pollfd, Q_PRIMITIVE_TYPE);
107 
108 // Internal operator functions for timespecs
normalizedTimespec(timespec & t)109 inline timespec &normalizedTimespec(timespec &t)
110 {
111     while (t.tv_nsec >= 1000000000) {
112         ++t.tv_sec;
113         t.tv_nsec -= 1000000000;
114     }
115     while (t.tv_nsec < 0) {
116         --t.tv_sec;
117         t.tv_nsec += 1000000000;
118     }
119     return t;
120 }
121 inline bool operator<(const timespec &t1, const timespec &t2)
122 { return t1.tv_sec < t2.tv_sec || (t1.tv_sec == t2.tv_sec && t1.tv_nsec < t2.tv_nsec); }
123 inline bool operator==(const timespec &t1, const timespec &t2)
124 { return t1.tv_sec == t2.tv_sec && t1.tv_nsec == t2.tv_nsec; }
125 inline bool operator!=(const timespec &t1, const timespec &t2)
126 { return !(t1 == t2); }
127 inline timespec &operator+=(timespec &t1, const timespec &t2)
128 {
129     t1.tv_sec += t2.tv_sec;
130     t1.tv_nsec += t2.tv_nsec;
131     return normalizedTimespec(t1);
132 }
133 inline timespec operator+(const timespec &t1, const timespec &t2)
134 {
135     timespec tmp;
136     tmp.tv_sec = t1.tv_sec + t2.tv_sec;
137     tmp.tv_nsec = t1.tv_nsec + t2.tv_nsec;
138     return normalizedTimespec(tmp);
139 }
140 inline timespec operator-(const timespec &t1, const timespec &t2)
141 {
142     timespec tmp;
143     tmp.tv_sec = t1.tv_sec - (t2.tv_sec - 1);
144     tmp.tv_nsec = t1.tv_nsec - (t2.tv_nsec + 1000000000);
145     return normalizedTimespec(tmp);
146 }
147 inline timespec operator*(const timespec &t1, int mul)
148 {
149     timespec tmp;
150     tmp.tv_sec = t1.tv_sec * mul;
151     tmp.tv_nsec = t1.tv_nsec * mul;
152     return normalizedTimespec(tmp);
153 }
timespecToTimeval(const timespec & ts)154 inline timeval timespecToTimeval(const timespec &ts)
155 {
156     timeval tv;
157     tv.tv_sec = ts.tv_sec;
158     tv.tv_usec = ts.tv_nsec / 1000;
159     return tv;
160 }
161 
162 
qt_ignore_sigpipe()163 inline void qt_ignore_sigpipe()
164 {
165     // Set to ignore SIGPIPE once only.
166     static QBasicAtomicInt atom = Q_BASIC_ATOMIC_INITIALIZER(0);
167     if (!atom.loadRelaxed()) {
168         // More than one thread could turn off SIGPIPE at the same time
169         // But that's acceptable because they all would be doing the same
170         // action
171         struct sigaction noaction;
172         memset(&noaction, 0, sizeof(noaction));
173         noaction.sa_handler = SIG_IGN;
174         ::sigaction(SIGPIPE, &noaction, nullptr);
175         atom.storeRelaxed(1);
176     }
177 }
178 
179 #if defined(Q_PROCESSOR_X86_32) && defined(__GLIBC__)
180 #  if !__GLIBC_PREREQ(2, 22)
181 Q_CORE_EXPORT int qt_open64(const char *pathname, int flags, mode_t);
182 #    undef QT_OPEN
183 #    define QT_OPEN qt_open64
184 #  endif
185 #endif
186 
187 // don't call QT_OPEN or ::open
188 // call qt_safe_open
189 static inline int qt_safe_open(const char *pathname, int flags, mode_t mode = 0777)
190 {
191 #ifdef O_CLOEXEC
192     flags |= O_CLOEXEC;
193 #endif
194     int fd;
195     EINTR_LOOP(fd, QT_OPEN(pathname, flags, mode));
196 
197 #ifndef O_CLOEXEC
198     if (fd != -1)
199         ::fcntl(fd, F_SETFD, FD_CLOEXEC);
200 #endif
201 
202     return fd;
203 }
204 #undef QT_OPEN
205 #define QT_OPEN         qt_safe_open
206 
207 #ifndef Q_OS_VXWORKS // no POSIX pipes in VxWorks
208 // don't call ::pipe
209 // call qt_safe_pipe
210 static inline int qt_safe_pipe(int pipefd[2], int flags = 0)
211 {
212     Q_ASSERT((flags & ~O_NONBLOCK) == 0);
213 
214 #ifdef QT_THREADSAFE_CLOEXEC
215     // use pipe2
216     flags |= O_CLOEXEC;
217     return ::pipe2(pipefd, flags); // pipe2 is documented not to return EINTR
218 #else
219     int ret = ::pipe(pipefd);
220     if (ret == -1)
221         return -1;
222 
223     ::fcntl(pipefd[0], F_SETFD, FD_CLOEXEC);
224     ::fcntl(pipefd[1], F_SETFD, FD_CLOEXEC);
225 
226     // set non-block too?
227     if (flags & O_NONBLOCK) {
228         ::fcntl(pipefd[0], F_SETFL, ::fcntl(pipefd[0], F_GETFL) | O_NONBLOCK);
229         ::fcntl(pipefd[1], F_SETFL, ::fcntl(pipefd[1], F_GETFL) | O_NONBLOCK);
230     }
231 
232     return 0;
233 #endif
234 }
235 
236 #endif // Q_OS_VXWORKS
237 
238 // don't call dup or fcntl(F_DUPFD)
239 static inline int qt_safe_dup(int oldfd, int atleast = 0, int flags = FD_CLOEXEC)
240 {
241     Q_ASSERT(flags == FD_CLOEXEC || flags == 0);
242 
243 #ifdef F_DUPFD_CLOEXEC
244     int cmd = F_DUPFD;
245     if (flags & FD_CLOEXEC)
246         cmd = F_DUPFD_CLOEXEC;
247     return ::fcntl(oldfd, cmd, atleast);
248 #else
249     // use F_DUPFD
250     int ret = ::fcntl(oldfd, F_DUPFD, atleast);
251 
252     if (flags && ret != -1)
253         ::fcntl(ret, F_SETFD, flags);
254     return ret;
255 #endif
256 }
257 
258 // don't call dup2
259 // call qt_safe_dup2
260 static inline int qt_safe_dup2(int oldfd, int newfd, int flags = FD_CLOEXEC)
261 {
262     Q_ASSERT(flags == FD_CLOEXEC || flags == 0);
263 
264     int ret;
265 #ifdef QT_THREADSAFE_CLOEXEC
266     // use dup3
267     EINTR_LOOP(ret, ::dup3(oldfd, newfd, flags ? O_CLOEXEC : 0));
268     return ret;
269 #else
270     EINTR_LOOP(ret, ::dup2(oldfd, newfd));
271     if (ret == -1)
272         return -1;
273 
274     if (flags)
275         ::fcntl(newfd, F_SETFD, flags);
276     return 0;
277 #endif
278 }
279 
qt_safe_read(int fd,void * data,qint64 maxlen)280 static inline qint64 qt_safe_read(int fd, void *data, qint64 maxlen)
281 {
282     qint64 ret = 0;
283     EINTR_LOOP(ret, QT_READ(fd, data, maxlen));
284     return ret;
285 }
286 #undef QT_READ
287 #define QT_READ qt_safe_read
288 
qt_safe_write(int fd,const void * data,qint64 len)289 static inline qint64 qt_safe_write(int fd, const void *data, qint64 len)
290 {
291     qint64 ret = 0;
292     EINTR_LOOP(ret, QT_WRITE(fd, data, len));
293     return ret;
294 }
295 #undef QT_WRITE
296 #define QT_WRITE qt_safe_write
297 
qt_safe_write_nosignal(int fd,const void * data,qint64 len)298 static inline qint64 qt_safe_write_nosignal(int fd, const void *data, qint64 len)
299 {
300     qt_ignore_sigpipe();
301     return qt_safe_write(fd, data, len);
302 }
303 
qt_safe_close(int fd)304 static inline int qt_safe_close(int fd)
305 {
306     int ret;
307     EINTR_LOOP(ret, QT_CLOSE(fd));
308     return ret;
309 }
310 #undef QT_CLOSE
311 #define QT_CLOSE qt_safe_close
312 
313 // - VxWorks & iOS/tvOS/watchOS don't have processes
314 #if QT_CONFIG(process)
qt_safe_execve(const char * filename,char * const argv[],char * const envp[])315 static inline int qt_safe_execve(const char *filename, char *const argv[],
316                                  char *const envp[])
317 {
318     int ret;
319     EINTR_LOOP(ret, ::execve(filename, argv, envp));
320     return ret;
321 }
322 
qt_safe_execv(const char * path,char * const argv[])323 static inline int qt_safe_execv(const char *path, char *const argv[])
324 {
325     int ret;
326     EINTR_LOOP(ret, ::execv(path, argv));
327     return ret;
328 }
329 
qt_safe_execvp(const char * file,char * const argv[])330 static inline int qt_safe_execvp(const char *file, char *const argv[])
331 {
332     int ret;
333     EINTR_LOOP(ret, ::execvp(file, argv));
334     return ret;
335 }
336 
qt_safe_waitpid(pid_t pid,int * status,int options)337 static inline pid_t qt_safe_waitpid(pid_t pid, int *status, int options)
338 {
339     int ret;
340     EINTR_LOOP(ret, ::waitpid(pid, status, options));
341     return ret;
342 }
343 #endif // QT_CONFIG(process)
344 
345 #if !defined(_POSIX_MONOTONIC_CLOCK)
346 #  define _POSIX_MONOTONIC_CLOCK -1
347 #endif
348 
349 // in qelapsedtimer_mac.cpp or qtimestamp_unix.cpp
350 timespec qt_gettime() noexcept;
351 void qt_nanosleep(timespec amount);
352 QByteArray qt_readlink(const char *path);
353 
354 /* non-static */
qt_haveLinuxProcfs()355 inline bool qt_haveLinuxProcfs()
356 {
357 #ifdef Q_OS_LINUX
358 #  ifdef QT_LINUX_ALWAYS_HAVE_PROCFS
359     return true;
360 #  else
361     static const bool present = (access("/proc/version", F_OK) == 0);
362     return present;
363 #  endif
364 #else
365     return false;
366 #endif
367 }
368 
369 Q_CORE_EXPORT int qt_safe_poll(struct pollfd *fds, nfds_t nfds, const struct timespec *timeout_ts);
370 
qt_poll_msecs(struct pollfd * fds,nfds_t nfds,int timeout)371 static inline int qt_poll_msecs(struct pollfd *fds, nfds_t nfds, int timeout)
372 {
373     timespec ts, *pts = nullptr;
374 
375     if (timeout >= 0) {
376         ts.tv_sec = timeout / 1000;
377         ts.tv_nsec = (timeout % 1000) * 1000 * 1000;
378         pts = &ts;
379     }
380 
381     return qt_safe_poll(fds, nfds, pts);
382 }
383 
qt_make_pollfd(int fd,short events)384 static inline struct pollfd qt_make_pollfd(int fd, short events)
385 {
386     struct pollfd pfd = { fd, events, 0 };
387     return pfd;
388 }
389 
390 // according to X/OPEN we have to define semun ourselves
391 // we use prefix as on some systems sem.h will have it
392 struct semid_ds;
393 union qt_semun {
394     int val;                    /* value for SETVAL */
395     struct semid_ds *buf;       /* buffer for IPC_STAT, IPC_SET */
396     unsigned short *array;      /* array for GETALL, SETALL */
397 };
398 
399 QT_END_NAMESPACE
400 
401 #endif
402