vnc: add missing static
[qemu/opensuse.git] / osdep.c
blobc822a01c04d68928db795d5816dcb3bcddab3f3a
1 /*
2 * QEMU low level functions
4 * Copyright (c) 2003 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
24 #include <stdlib.h>
25 #include <stdio.h>
26 #include <stdarg.h>
27 #include <stdbool.h>
28 #include <string.h>
29 #include <errno.h>
30 #include <unistd.h>
31 #include <fcntl.h>
33 /* Needed early for CONFIG_BSD etc. */
34 #include "config-host.h"
36 #if defined(CONFIG_MADVISE) || defined(CONFIG_POSIX_MADVISE)
37 #include <sys/mman.h>
38 #endif
40 #ifdef CONFIG_SOLARIS
41 #include <sys/types.h>
42 #include <sys/statvfs.h>
43 /* See MySQL bug #7156 (http://bugs.mysql.com/bug.php?id=7156) for
44 discussion about Solaris header problems */
45 extern int madvise(caddr_t, size_t, int);
46 #endif
48 #include "qemu-common.h"
49 #include "trace.h"
50 #include "qemu_socket.h"
51 #include "monitor.h"
53 static bool fips_enabled = false;
55 static const char *qemu_version = QEMU_VERSION;
57 int socket_set_cork(int fd, int v)
59 #if defined(SOL_TCP) && defined(TCP_CORK)
60 return setsockopt(fd, SOL_TCP, TCP_CORK, &v, sizeof(v));
61 #else
62 return 0;
63 #endif
66 int qemu_madvise(void *addr, size_t len, int advice)
68 if (advice == QEMU_MADV_INVALID) {
69 errno = EINVAL;
70 return -1;
72 #if defined(CONFIG_MADVISE)
73 return madvise(addr, len, advice);
74 #elif defined(CONFIG_POSIX_MADVISE)
75 return posix_madvise(addr, len, advice);
76 #else
77 errno = EINVAL;
78 return -1;
79 #endif
82 #ifndef _WIN32
84 * Dups an fd and sets the flags
86 static int qemu_dup_flags(int fd, int flags)
88 int ret;
89 int serrno;
90 int dup_flags;
92 #ifdef F_DUPFD_CLOEXEC
93 ret = fcntl(fd, F_DUPFD_CLOEXEC, 0);
94 #else
95 ret = dup(fd);
96 if (ret != -1) {
97 qemu_set_cloexec(ret);
99 #endif
100 if (ret == -1) {
101 goto fail;
104 dup_flags = fcntl(ret, F_GETFL);
105 if (dup_flags == -1) {
106 goto fail;
109 if ((flags & O_SYNC) != (dup_flags & O_SYNC)) {
110 errno = EINVAL;
111 goto fail;
114 /* Set/unset flags that we can with fcntl */
115 if (fcntl(ret, F_SETFL, flags) == -1) {
116 goto fail;
119 /* Truncate the file in the cases that open() would truncate it */
120 if (flags & O_TRUNC ||
121 ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))) {
122 if (ftruncate(ret, 0) == -1) {
123 goto fail;
127 return ret;
129 fail:
130 serrno = errno;
131 if (ret != -1) {
132 close(ret);
134 errno = serrno;
135 return -1;
137 #endif
140 * Opens a file with FD_CLOEXEC set
142 int qemu_open(const char *name, int flags, ...)
144 int ret;
145 int mode = 0;
147 #ifndef _WIN32
148 const char *fdset_id_str;
150 /* Attempt dup of fd from fd set */
151 if (strstart(name, "/dev/fdset/", &fdset_id_str)) {
152 int64_t fdset_id;
153 int fd, dupfd;
155 fdset_id = qemu_parse_fdset(fdset_id_str);
156 if (fdset_id == -1) {
157 errno = EINVAL;
158 return -1;
161 fd = monitor_fdset_get_fd(fdset_id, flags);
162 if (fd == -1) {
163 return -1;
166 dupfd = qemu_dup_flags(fd, flags);
167 if (dupfd == -1) {
168 return -1;
171 ret = monitor_fdset_dup_fd_add(fdset_id, dupfd);
172 if (ret == -1) {
173 close(dupfd);
174 errno = EINVAL;
175 return -1;
178 return dupfd;
180 #endif
182 if (flags & O_CREAT) {
183 va_list ap;
185 va_start(ap, flags);
186 mode = va_arg(ap, int);
187 va_end(ap);
190 #ifdef O_CLOEXEC
191 ret = open(name, flags | O_CLOEXEC, mode);
192 #else
193 ret = open(name, flags, mode);
194 if (ret >= 0) {
195 qemu_set_cloexec(ret);
197 #endif
199 return ret;
202 int qemu_close(int fd)
204 int64_t fdset_id;
206 /* Close fd that was dup'd from an fdset */
207 fdset_id = monitor_fdset_dup_fd_find(fd);
208 if (fdset_id != -1) {
209 int ret;
211 ret = close(fd);
212 if (ret == 0) {
213 monitor_fdset_dup_fd_remove(fd);
216 return ret;
219 return close(fd);
223 * A variant of write(2) which handles partial write.
225 * Return the number of bytes transferred.
226 * Set errno if fewer than `count' bytes are written.
228 * This function don't work with non-blocking fd's.
229 * Any of the possibilities with non-bloking fd's is bad:
230 * - return a short write (then name is wrong)
231 * - busy wait adding (errno == EAGAIN) to the loop
233 ssize_t qemu_write_full(int fd, const void *buf, size_t count)
235 ssize_t ret = 0;
236 ssize_t total = 0;
238 while (count) {
239 ret = write(fd, buf, count);
240 if (ret < 0) {
241 if (errno == EINTR)
242 continue;
243 break;
246 count -= ret;
247 buf += ret;
248 total += ret;
251 return total;
255 * Opens a socket with FD_CLOEXEC set
257 int qemu_socket(int domain, int type, int protocol)
259 int ret;
261 #ifdef SOCK_CLOEXEC
262 ret = socket(domain, type | SOCK_CLOEXEC, protocol);
263 if (ret != -1 || errno != EINVAL) {
264 return ret;
266 #endif
267 ret = socket(domain, type, protocol);
268 if (ret >= 0) {
269 qemu_set_cloexec(ret);
272 return ret;
276 * Accept a connection and set FD_CLOEXEC
278 int qemu_accept(int s, struct sockaddr *addr, socklen_t *addrlen)
280 int ret;
282 #ifdef CONFIG_ACCEPT4
283 ret = accept4(s, addr, addrlen, SOCK_CLOEXEC);
284 if (ret != -1 || errno != ENOSYS) {
285 return ret;
287 #endif
288 ret = accept(s, addr, addrlen);
289 if (ret >= 0) {
290 qemu_set_cloexec(ret);
293 return ret;
297 * A variant of send(2) which handles partial write.
299 * Return the number of bytes transferred, which is only
300 * smaller than `count' if there is an error.
302 * This function won't work with non-blocking fd's.
303 * Any of the possibilities with non-bloking fd's is bad:
304 * - return a short write (then name is wrong)
305 * - busy wait adding (errno == EAGAIN) to the loop
307 ssize_t qemu_send_full(int fd, const void *buf, size_t count, int flags)
309 ssize_t ret = 0;
310 ssize_t total = 0;
312 while (count) {
313 ret = send(fd, buf, count, flags);
314 if (ret < 0) {
315 if (errno == EINTR) {
316 continue;
318 break;
321 count -= ret;
322 buf += ret;
323 total += ret;
326 return total;
330 * A variant of recv(2) which handles partial write.
332 * Return the number of bytes transferred, which is only
333 * smaller than `count' if there is an error.
335 * This function won't work with non-blocking fd's.
336 * Any of the possibilities with non-bloking fd's is bad:
337 * - return a short write (then name is wrong)
338 * - busy wait adding (errno == EAGAIN) to the loop
340 ssize_t qemu_recv_full(int fd, void *buf, size_t count, int flags)
342 ssize_t ret = 0;
343 ssize_t total = 0;
345 while (count) {
346 ret = qemu_recv(fd, buf, count, flags);
347 if (ret <= 0) {
348 if (ret < 0 && errno == EINTR) {
349 continue;
351 break;
354 count -= ret;
355 buf += ret;
356 total += ret;
359 return total;
362 void qemu_set_version(const char *version)
364 qemu_version = version;
367 const char *qemu_get_version(void)
369 return qemu_version;
372 void fips_set_state(bool requested)
374 #ifdef __linux__
375 if (requested) {
376 FILE *fds = fopen("/proc/sys/crypto/fips_enabled", "r");
377 if (fds != NULL) {
378 fips_enabled = (fgetc(fds) == '1');
379 fclose(fds);
382 #else
383 fips_enabled = false;
384 #endif /* __linux__ */
386 #ifdef _FIPS_DEBUG
387 fprintf(stderr, "FIPS mode %s (requested %s)\n",
388 (fips_enabled ? "enabled" : "disabled"),
389 (requested ? "enabled" : "disabled"));
390 #endif
393 bool fips_get_state(void)
395 return fips_enabled;