D-Bus 1.14.10
dbus-sysdeps.h
1/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
2/* dbus-sysdeps.h Wrappers around system/libc features (internal to D-Bus implementation)
3 *
4 * Copyright (C) 2002, 2003 Red Hat, Inc.
5 * Copyright (C) 2003 CodeFactory AB
6 *
7 * Licensed under the Academic Free License version 2.1
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 *
23 */
24
25#ifndef DBUS_SYSDEPS_H
26#define DBUS_SYSDEPS_H
27
28#ifndef VERSION
29#warning Please include config.h before dbus-sysdeps.h
30#include "config.h"
31#endif
32
33#ifdef HAVE_STDINT_H
34#include <stdint.h>
35#endif
36
37#ifdef HAVE_INTTYPES_H
38#include <inttypes.h>
39#endif
40
41#include <dbus/dbus-errors.h>
42#include <dbus/dbus-file.h>
43#include <dbus/dbus-string.h>
44
45/* this is perhaps bogus, but strcmp() etc. are faster if we use the
46 * stuff straight out of string.h, so have this here for now.
47 */
48#include <string.h>
49#include <stdarg.h>
50
51#if !defined(BROKEN_POLL) && (defined(__APPLE__) || defined(__INTERIX))
52 /* Following libcurl's example, we blacklist poll() on Darwin
53 * (macOS, iOS, etc.) and Interix due to a history of implementation
54 * issues.
55 * https://github.com/curl/curl/blob/master/m4/curl-functions.m4
56 *
57 * On unspecified older macOS versions, poll() failed if given a
58 * device node to poll.
59 *
60 * On macOS < 10.9, poll() with nfds=0 failed instead of waiting for
61 * the timeout and then succeeding.
62 *
63 * On macOS >= 10.12, poll() with nfds=0 succeeded immediately
64 * instead of waiting for the timeout, resulting in busy-looping.
65 *
66 * On Interix, poll() apparently only works for files in /proc.
67 *
68 * The "legacy" build flavour in our CI machinery defines BROKEN_POLL
69 * on whatever platform is in use (normally Linux) to force use of the
70 * same select()-based poll() emulation that we use for macOS, Interix,
71 * and any platform that lacks a real poll(), so that we can test it
72 * more regularly.
73 */
74# define BROKEN_POLL
75#endif
76
77/* Normally we'd only include this in dbus-sysdeps-unix.c.
78 * However, the member names in DBusPollFD are (deliberately) the same as
79 * in POSIX struct pollfd, and AIX's poll() implementation is known to
80 * do things like "#define events reqevents", which would break that approach.
81 * Defend against that by ensuring that if it's renamed anywhere, it's renamed
82 * everywhere.
83 */
84#ifdef HAVE_POLL
85#include <poll.h>
86#endif
87
88#ifdef DBUS_WINCE
89/* Windows CE lacks some system functions (such as errno and clock).
90 We bring them in here. */
91#include "dbus-sysdeps-wince-glue.h"
92#endif
93
94#ifdef DBUS_WIN
95#include <ws2tcpip.h>
96#endif
97
99
100#ifdef DBUS_WIN
101#define _DBUS_PATH_SEPARATOR ";"
102#else
103#define _DBUS_PATH_SEPARATOR ":"
104#endif
105
106/* Forward declarations */
107
108
110typedef struct DBusList DBusList;
111
113typedef struct DBusCredentials DBusCredentials;
114
116typedef struct DBusPipe DBusPipe;
117
123
124DBUS_PRIVATE_EXPORT
125void _dbus_abort (void) _DBUS_GNUC_NORETURN;
126
128DBUS_PRIVATE_EXPORT
129const char* _dbus_getenv (const char *varname);
130DBUS_PRIVATE_EXPORT
132char ** _dbus_get_environment (void);
133
135typedef unsigned long dbus_pid_t;
137typedef unsigned long dbus_uid_t;
139typedef unsigned long dbus_gid_t;
140
142#define DBUS_PID_UNSET ((dbus_pid_t) -1)
144#define DBUS_UID_UNSET ((dbus_uid_t) -1)
146#define DBUS_GID_UNSET ((dbus_gid_t) -1)
147
149#define DBUS_PID_FORMAT "%lu"
151#define DBUS_UID_FORMAT "%lu"
153#define DBUS_GID_FORMAT "%lu"
154
158#ifdef DBUS_WIN
159
160typedef struct { SOCKET sock; } DBusSocket;
161# define DBUS_SOCKET_FORMAT "Iu"
162# define DBUS_SOCKET_INIT { INVALID_SOCKET }
163
164_DBUS_WARN_UNUSED_RESULT
165static inline SOCKET
166_dbus_socket_printable (DBusSocket s) { return s.sock; }
167
168_DBUS_WARN_UNUSED_RESULT
169static inline dbus_bool_t
170_dbus_socket_is_valid (DBusSocket s) { return s.sock != INVALID_SOCKET; }
171
172static inline void
173_dbus_socket_invalidate (DBusSocket *s) { s->sock = INVALID_SOCKET; }
174
175_DBUS_WARN_UNUSED_RESULT
176static inline int
177_dbus_socket_get_int (DBusSocket s) { return (int)s.sock; }
178
179#else /* not DBUS_WIN */
180
181typedef struct { int fd; } DBusSocket;
182# define DBUS_SOCKET_FORMAT "d"
183# define DBUS_SOCKET_INIT { -1 }
184
185_DBUS_WARN_UNUSED_RESULT
186static inline int
187_dbus_socket_printable (DBusSocket s) { return s.fd; }
188
189_DBUS_WARN_UNUSED_RESULT
190static inline dbus_bool_t
191_dbus_socket_is_valid (DBusSocket s) { return s.fd >= 0; }
192
193static inline void
194_dbus_socket_invalidate (DBusSocket *s) { s->fd = -1; }
195
196_DBUS_WARN_UNUSED_RESULT
197static inline int
198_dbus_socket_get_int (DBusSocket s) { return s.fd; }
199
200#endif /* not DBUS_WIN */
201
202_DBUS_WARN_UNUSED_RESULT
203static inline DBusSocket
204_dbus_socket_get_invalid (void)
205{
206 DBusSocket s = DBUS_SOCKET_INIT;
207
208 return s;
209}
210
212 DBusError *error);
213
214DBUS_PRIVATE_EXPORT
216 DBusError *error);
217DBUS_PRIVATE_EXPORT
219 DBusString *buffer,
220 int count);
221DBUS_PRIVATE_EXPORT
223 const DBusString *buffer,
224 int start,
225 int len);
227 const DBusString *buffer1,
228 int start1,
229 int len1,
230 const DBusString *buffer2,
231 int start2,
232 int len2);
233
235 DBusString *buffer,
236 int count,
237 int *fds,
238 unsigned int *n_fds);
239DBUS_PRIVATE_EXPORT
240int _dbus_write_socket_with_unix_fds (DBusSocket fd,
241 const DBusString *buffer,
242 int start,
243 int len,
244 const int *fds,
245 int n_fds);
246int _dbus_write_socket_with_unix_fds_two (DBusSocket fd,
247 const DBusString *buffer1,
248 int start1,
249 int len1,
250 const DBusString *buffer2,
251 int start2,
252 int len2,
253 const int *fds,
254 int n_fds);
255
256DBusSocket _dbus_connect_tcp_socket (const char *host,
257 const char *port,
258 const char *family,
259 DBusError *error);
260DBusSocket _dbus_connect_tcp_socket_with_nonce (const char *host,
261 const char *port,
262 const char *family,
263 const char *noncefile,
264 DBusError *error);
265int _dbus_listen_tcp_socket (const char *host,
266 const char *port,
267 const char *family,
268 DBusString *retport,
269 const char **retfamily,
270 DBusSocket **fds_p,
271 DBusError *error);
273
275 DBusCredentials *credentials,
276 DBusError *error);
278 DBusError *error);
279
280typedef enum
281{
282 DBUS_CREDENTIALS_ADD_FLAGS_USER_DATABASE = (1 << 0),
283 DBUS_CREDENTIALS_ADD_FLAGS_NONE = 0
284} DBusCredentialsAddFlags;
285
287 const DBusString *username,
288 DBusCredentialsAddFlags flags,
289 DBusError *error);
290
292DBUS_PRIVATE_EXPORT
294
296 dbus_uid_t *uid_p);
298 dbus_gid_t *gid_p);
300 dbus_gid_t **group_ids,
301 int *n_group_ids,
302 DBusError *error);
304 DBusError *error);
306dbus_bool_t _dbus_windows_user_is_process_owner (const char *windows_sid);
307
309 DBusCredentials *credentials);
310
312
314
318typedef struct DBusAtomic DBusAtomic;
319
324{
325#ifdef DBUS_WIN
326 volatile long value;
327#else
328 volatile dbus_int32_t value;
329#endif
330};
331
332DBUS_PRIVATE_EXPORT
333dbus_int32_t _dbus_atomic_inc (DBusAtomic *atomic);
334DBUS_PRIVATE_EXPORT
335dbus_int32_t _dbus_atomic_dec (DBusAtomic *atomic);
336DBUS_PRIVATE_EXPORT
337dbus_int32_t _dbus_atomic_get (DBusAtomic *atomic);
338DBUS_PRIVATE_EXPORT
339void _dbus_atomic_set_zero (DBusAtomic *atomic);
340DBUS_PRIVATE_EXPORT
342
343#ifdef DBUS_WIN
344
345/* On Windows, you can only poll sockets. We emulate Unix poll() using
346 * select(), so it doesn't matter what precise type we put in DBusPollFD;
347 * use DBusSocket so that the compiler can check we are doing it right.
348 */
349typedef DBusSocket DBusPollable;
350# define DBUS_POLLABLE_FORMAT "Iu"
351
352static inline DBusPollable
353_dbus_socket_get_pollable (DBusSocket s) { return s; }
354
355static inline SOCKET
356_dbus_pollable_printable (DBusPollable p) { return p.sock; }
357
358static inline dbus_bool_t
359_dbus_pollable_is_valid (DBusPollable p) { return _dbus_socket_is_valid (p); }
360
361static inline void
362_dbus_pollable_invalidate (DBusPollable *p) { _dbus_socket_invalidate (p); }
363
364static inline dbus_bool_t
365_dbus_pollable_equals (DBusPollable a, DBusPollable b) { return a.sock == b.sock; }
366
367#else /* !DBUS_WIN */
368
369/* On Unix, you can poll sockets, pipes, etc., and we must put exactly
370 * "int" in DBusPollFD because we're relying on its layout exactly matching
371 * struct pollfd. (This is silly, and one day we should use a better
372 * abstraction.)
373 */
374typedef int DBusPollable;
375# define DBUS_POLLABLE_FORMAT "d"
376
377static inline DBusPollable
378_dbus_socket_get_pollable (DBusSocket s) { return s.fd; }
379
380static inline int
381_dbus_pollable_printable (DBusPollable p) { return p; }
382
383static inline dbus_bool_t
384_dbus_pollable_is_valid (DBusPollable p) { return p >= 0; }
385
386static inline void
387_dbus_pollable_invalidate (DBusPollable *p) { *p = -1; }
388
389static inline dbus_bool_t
390_dbus_pollable_equals (DBusPollable a, DBusPollable b) { return a == b; }
391
392#endif /* !DBUS_WIN */
393
394#if defined(HAVE_POLL) && !defined(BROKEN_POLL)
399typedef struct pollfd DBusPollFD;
400
402#define _DBUS_POLLIN POLLIN
404#define _DBUS_POLLPRI POLLPRI
406#define _DBUS_POLLOUT POLLOUT
408#define _DBUS_POLLERR POLLERR
410#define _DBUS_POLLHUP POLLHUP
412#define _DBUS_POLLNVAL POLLNVAL
413#else
414/* Emulate poll() via select(). Because we aren't really going to call
415 * poll(), any similarly-shaped struct is acceptable, and any power of 2
416 * will do for the events/revents; these values happen to match Linux
417 * and *BSD. */
418typedef struct
419{
420 DBusPollable fd;
421 short events;
422 short revents;
423} DBusPollFD;
424
426#define _DBUS_POLLIN 0x0001
428#define _DBUS_POLLPRI 0x0002
430#define _DBUS_POLLOUT 0x0004
432#define _DBUS_POLLERR 0x0008
434#define _DBUS_POLLHUP 0x0010
436#define _DBUS_POLLNVAL 0x0020
437#endif
438
439DBUS_PRIVATE_EXPORT
440int _dbus_poll (DBusPollFD *fds,
441 int n_fds,
442 int timeout_milliseconds);
443
444DBUS_PRIVATE_EXPORT
445void _dbus_sleep_milliseconds (int milliseconds);
446
447DBUS_PRIVATE_EXPORT
448void _dbus_get_monotonic_time (long *tv_sec,
449 long *tv_usec);
450
451DBUS_PRIVATE_EXPORT
452void _dbus_get_real_time (long *tv_sec,
453 long *tv_usec);
454
458DBUS_PRIVATE_EXPORT
460 DBusError *error);
461DBUS_PRIVATE_EXPORT
463 DBusError *error);
464DBUS_PRIVATE_EXPORT
466 DBusError *error);
467
468DBUS_PRIVATE_EXPORT
470 const DBusString *next_component);
472 DBusString *dirname);
473DBUS_PRIVATE_EXPORT
475
479 DBusError *error);
480
483
486
488 DBusError *error);
490 DBusString *filename,
491 DBusError *error);
493
495 DBusError *error);
496
497DBUS_PRIVATE_EXPORT
498const char* _dbus_get_tmpdir (void);
499
503_DBUS_WARN_UNUSED_RESULT
505 int n_bytes,
506 DBusError *error);
508 int n_bytes,
509 DBusError *error);
510DBUS_PRIVATE_EXPORT
512 int n_bytes,
513 DBusError *error);
514
515DBUS_PRIVATE_EXPORT
516const char* _dbus_error_from_errno (int error_number);
517DBUS_PRIVATE_EXPORT
518const char* _dbus_error_from_system_errno (void);
519
520int _dbus_get_low_level_socket_errno (void);
521
522int _dbus_save_socket_errno (void);
523void _dbus_restore_socket_errno (int saved_errno);
524void _dbus_set_errno_to_zero (void);
530DBUS_PRIVATE_EXPORT
531const char* _dbus_strerror_from_errno (void);
532
533void _dbus_disable_sigpipe (void);
534
535DBUS_PRIVATE_EXPORT
536void _dbus_exit (int code) _DBUS_GNUC_NORETURN;
537
538DBUS_PRIVATE_EXPORT
539int _dbus_printf_string_upper_bound (const char *format,
540 va_list args) _DBUS_GNUC_PRINTF (1, 0);
541
542#ifdef DBUS_ENABLE_VERBOSE_MODE
543DBUS_PRIVATE_EXPORT
544void _dbus_print_thread (void);
545#endif
546
550typedef struct
551{
552 unsigned long mode;
553 unsigned long nlink;
556 unsigned long size;
557 unsigned long atime;
558 unsigned long mtime;
559 unsigned long ctime;
560} DBusStat;
561
562dbus_bool_t _dbus_stat (const DBusString *filename,
563 DBusStat *statbuf,
564 DBusError *error);
565DBUS_PRIVATE_EXPORT
567 DBusSocket *fd2,
568 dbus_bool_t blocking,
569 DBusError *error);
570
571DBUS_PRIVATE_EXPORT
572void _dbus_print_backtrace (void);
573
575 DBusPipe *print_pid_pipe,
576 DBusError *error,
577 dbus_bool_t keep_umask);
578
579dbus_bool_t _dbus_verify_daemon_user (const char *user);
581 DBusError *error);
582
584 DBusPipe *print_pid_pipe,
585 dbus_pid_t pid_to_write,
586 DBusError *error);
587
588dbus_bool_t _dbus_command_for_pid (unsigned long pid,
589 DBusString *str,
590 int max_len,
591 DBusError *error);
592
593dbus_bool_t _dbus_user_at_console (const char *username,
594 DBusError *error);
595
596typedef enum {
597 DBUS_LOG_FLAGS_STDERR = (1 << 0),
598 DBUS_LOG_FLAGS_SYSTEM_LOG = (1 << 1)
599} DBusLogFlags;
600
601DBUS_PRIVATE_EXPORT
602void _dbus_init_system_log (const char *tag,
603 DBusLogFlags flags);
604
605typedef enum {
606 DBUS_SYSTEM_LOG_INFO,
607 DBUS_SYSTEM_LOG_WARNING,
608 DBUS_SYSTEM_LOG_SECURITY,
609 DBUS_SYSTEM_LOG_ERROR
610} DBusSystemLogSeverity;
611
612DBUS_PRIVATE_EXPORT
613void _dbus_log (DBusSystemLogSeverity severity,
614 const char *msg,
615 ...) _DBUS_GNUC_PRINTF (2, 3);
616DBUS_PRIVATE_EXPORT
617void _dbus_logv (DBusSystemLogSeverity severity,
618 const char *msg,
619 va_list args) _DBUS_GNUC_PRINTF (2, 0);
620
625#define _DBUS_BYTE_OF_PRIMITIVE(p, i) \
626 (((const char*)&(p))[(i)])
627
632#define _DBUS_DOUBLES_BITWISE_EQUAL(a, b) \
633 (_DBUS_BYTE_OF_PRIMITIVE (a, 0) == _DBUS_BYTE_OF_PRIMITIVE (b, 0) && \
634 _DBUS_BYTE_OF_PRIMITIVE (a, 1) == _DBUS_BYTE_OF_PRIMITIVE (b, 1) && \
635 _DBUS_BYTE_OF_PRIMITIVE (a, 2) == _DBUS_BYTE_OF_PRIMITIVE (b, 2) && \
636 _DBUS_BYTE_OF_PRIMITIVE (a, 3) == _DBUS_BYTE_OF_PRIMITIVE (b, 3) && \
637 _DBUS_BYTE_OF_PRIMITIVE (a, 4) == _DBUS_BYTE_OF_PRIMITIVE (b, 4) && \
638 _DBUS_BYTE_OF_PRIMITIVE (a, 5) == _DBUS_BYTE_OF_PRIMITIVE (b, 5) && \
639 _DBUS_BYTE_OF_PRIMITIVE (a, 6) == _DBUS_BYTE_OF_PRIMITIVE (b, 6) && \
640 _DBUS_BYTE_OF_PRIMITIVE (a, 7) == _DBUS_BYTE_OF_PRIMITIVE (b, 7))
641
643 DBusString *address,
644 DBusError *error);
645
647 DBusString *address,
648 DBusError *error);
649
653typedef union DBusGUID DBusGUID;
654
655DBUS_PRIVATE_EXPORT
657 dbus_bool_t create_if_not_found,
658 DBusError *error);
659
666
671
676
677DBUS_PRIVATE_EXPORT
679 const char *suffix,
680 DBusList **dir_list);
681
682unsigned long _dbus_pid_for_log (void);
683
684/* FIXME move back to dbus-sysdeps-unix.h probably -
685 * the PID file handling just needs a little more abstraction
686 * in the bus daemon first.
687 */
688DBUS_PRIVATE_EXPORT
690
691DBUS_PRIVATE_EXPORT
693
694DBUS_PRIVATE_EXPORT
695void _dbus_flush_caches (void);
696
698
699/* Do not set this too high: it is a denial-of-service risk.
700 * See <https://bugs.freedesktop.org/show_bug.cgi?id=82820>
701 *
702 * (This needs to be in the non-Unix-specific header so that
703 * the config-parser can use it.)
704 */
705#define DBUS_DEFAULT_MESSAGE_UNIX_FDS 16
706
707typedef struct DBusRLimit DBusRLimit;
708
709DBusRLimit *_dbus_rlimit_save_fd_limit (DBusError *error);
710dbus_bool_t _dbus_rlimit_raise_fd_limit (DBusError *error);
711dbus_bool_t _dbus_rlimit_restore_fd_limit (DBusRLimit *saved,
712 DBusError *error);
713void _dbus_rlimit_free (DBusRLimit *lim);
714
715void _dbus_daemon_report_ready (void);
719
720dbus_bool_t _dbus_inet_sockaddr_to_string (const void *sockaddr_pointer,
721 size_t len,
722 char *string,
723 size_t string_len,
724 const char **family_name,
725 dbus_uint16_t *port,
726 DBusError *error);
727void _dbus_set_error_with_inet_sockaddr (DBusError *error,
728 const void *sockaddr_pointer,
729 size_t len,
730 const char *description,
731 int saved_errno);
732void _dbus_combine_tcp_errors (DBusList **sources,
733 const char *summary,
734 const char *host,
735 const char *port,
736 DBusError *dest);
737
739
741
742
743#ifdef DBUS_WIN
744#include "dbus-sysdeps-win.h"
745#endif
746
747#endif /* DBUS_SYSDEPS_H */
#define DBUS_BEGIN_DECLS
Macro used prior to declaring functions in the D-Bus header files.
Definition dbus-macros.h:34
#define DBUS_END_DECLS
Macro used after declaring functions in the D-Bus header files.
Definition dbus-macros.h:35
void _dbus_logv(DBusSystemLogSeverity severity, const char *msg, va_list args)
Log a message to the system log file (e.g.
dbus_bool_t _dbus_stat(const DBusString *filename, DBusStat *statbuf, DBusError *error)
stat() wrapper.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_read_local_machine_uuid(DBusGUID *machine_id, dbus_bool_t create_if_not_found, DBusError *error)
Reads the uuid of the machine we're running on from the dbus configuration.
dbus_bool_t _dbus_get_standard_session_servicedirs(DBusList **dirs)
Returns the standard directories for a session bus to look for service activation files.
dbus_bool_t _dbus_get_is_errno_epipe(int e)
See if errno is EPIPE.
void _dbus_daemon_report_ready(void)
Report to a service manager that the daemon calling this function is ready for use.
dbus_bool_t _dbus_get_is_errno_etoomanyrefs(int e)
See if errno is ETOOMANYREFS.
dbus_bool_t _dbus_write_pid_to_file_and_pipe(const DBusString *pidfile, DBusPipe *print_pid_pipe, dbus_pid_t pid_to_write, DBusError *error)
Writes the given pid_to_write to a pidfile (if non-NULL) and/or to a pipe (if non-NULL).
void _dbus_directory_close(DBusDirIter *iter)
Closes a directory iteration.
unsigned long dbus_uid_t
A user ID.
dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock(int e)
See if errno is EAGAIN or EWOULDBLOCK (this has to be done differently for Winsock so is abstracted)
_DBUS_WARN_UNUSED_RESULT dbus_bool_t _dbus_generate_random_bytes_buffer(char *buffer, int n_bytes, DBusError *error)
Random numbers.
unsigned long _dbus_pid_for_log(void)
The only reason this is separate from _dbus_getpid() is to allow it on Windows for logging but not fo...
dbus_bool_t _dbus_get_session_config_file(DBusString *str)
Get the absolute path of the session.conf file.
dbus_bool_t _dbus_clearenv(void)
Wrapper for clearenv().
unsigned long dbus_pid_t
A process ID.
DBUS_PRIVATE_EXPORT int _dbus_read_socket(DBusSocket fd, DBusString *buffer, int count)
Like _dbus_read(), but only works on sockets so is available on Windows.
void _dbus_daemon_report_reloading(void)
Report to a service manager that the daemon calling this function is reloading configuration.
DBUS_PRIVATE_EXPORT void _dbus_exit(int code) _DBUS_GNUC_NORETURN
Exit the process, returning the given value.
dbus_bool_t _dbus_socket_can_pass_unix_fd(DBusSocket fd)
Checks whether file descriptors may be passed via the socket.
DBUS_PRIVATE_EXPORT int _dbus_write_socket(DBusSocket fd, const DBusString *buffer, int start, int len)
Like _dbus_write(), but only supports sockets and is thus available on Windows.
DBUS_PRIVATE_EXPORT void _dbus_atomic_set_nonzero(DBusAtomic *atomic)
Atomically set the value of an integer to something nonzero.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_socketpair(DBusSocket *fd1, DBusSocket *fd2, dbus_bool_t blocking, DBusError *error)
Creates pair of connect sockets (as in socketpair()).
unsigned long dbus_gid_t
A group ID.
int _dbus_read_socket_with_unix_fds(DBusSocket fd, DBusString *buffer, int count, int *fds, unsigned int *n_fds)
Like _dbus_read_socket() but also tries to read unix fds from the socket.
dbus_bool_t _dbus_user_at_console(const char *username, DBusError *error)
Checks if user is at the console.
dbus_bool_t _dbus_command_for_pid(unsigned long pid, DBusString *str, int max_len, DBusError *error)
Get a printable string describing the command used to execute the process with pid.
dbus_bool_t _dbus_get_system_config_file(DBusString *str)
Get the absolute path of the system.conf file (there is no system bus on Windows so this can just ret...
DBusDirIter * _dbus_directory_open(const DBusString *filename, DBusError *error)
Open a directory to iterate over.
dbus_bool_t _dbus_set_up_transient_session_servicedirs(DBusList **dirs, DBusError *error)
Returns the standard directories for a session bus to look for transient service activation files.
dbus_bool_t _dbus_append_keyring_directory_for_credentials(DBusString *directory, DBusCredentials *credentials)
Appends the directory in which a keyring for the given credentials should be stored.
char ** _dbus_get_environment(void)
Gets a NULL-terminated list of key=value pairs from the environment.
dbus_bool_t _dbus_parse_unix_user_from_config(const DBusString *username, dbus_uid_t *uid_p)
Parse a UNIX user from the bus config file.
DBUS_PRIVATE_EXPORT dbus_int32_t _dbus_atomic_dec(DBusAtomic *atomic)
Atomically decrement an integer.
dbus_bool_t _dbus_verify_daemon_user(const char *user)
Verify that after the fork we can successfully change to this user.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_close_socket(DBusSocket fd, DBusError *error)
Closes a socket.
dbus_bool_t _dbus_read_credentials_socket(DBusSocket client_fd, DBusCredentials *credentials, DBusError *error)
Reads a single byte which must be nul (an error occurs otherwise), and reads unix credentials if avai...
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
dbus_bool_t _dbus_get_standard_system_servicedirs(DBusList **dirs)
Returns the standard directories for a system bus to look for service activation files.
DBUS_PRIVATE_EXPORT dbus_pid_t _dbus_getpid(void)
Gets our process ID.
DBUS_PRIVATE_EXPORT dbus_int32_t _dbus_atomic_get(DBusAtomic *atomic)
Atomically get the value of an integer.
dbus_bool_t _dbus_set_socket_nonblocking(DBusSocket fd, DBusError *error)
Sets a file descriptor to be nonblocking.
DBUS_PRIVATE_EXPORT const char * _dbus_error_from_system_errno(void)
Converts the current system errno value into a DBusError name.
dbus_bool_t _dbus_credentials_add_from_user(DBusCredentials *credentials, const DBusString *username, DBusCredentialsAddFlags flags, DBusError *error)
Adds the credentials corresponding to the given username.
DBusSocket _dbus_connect_tcp_socket(const char *host, const char *port, const char *family, DBusError *error)
Creates a socket and connects to a socket at the given host and port.
void _dbus_threads_lock_platform_specific(void)
Lock a static mutex used to protect _dbus_threads_init_platform_specific().
void _dbus_disable_sigpipe(void)
signal (SIGPIPE, SIG_IGN);
dbus_bool_t _dbus_check_setuid(void)
NOTE: If you modify this function, please also consider making the corresponding change in GLib.
void _dbus_daemon_report_reloaded(void)
Report to a service manager that the daemon calling this function is reloading configuration.
DBUS_PRIVATE_EXPORT void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
void _dbus_daemon_unpublish_session_bus_address(void)
Clear the platform-specific centralized location where the session bus address is published.
dbus_bool_t _dbus_change_to_daemon_user(const char *user, DBusError *error)
Changes the user and group the bus is running as.
dbus_bool_t _dbus_unix_user_is_process_owner(dbus_uid_t uid)
Checks to see if the UNIX user ID matches the UID of the process.
DBUS_PRIVATE_EXPORT const char * _dbus_strerror_from_errno(void)
Get error message from errno.
dbus_bool_t _dbus_check_dir_is_private_to_user(DBusString *dir, DBusError *error)
Checks to make sure the given directory is private to the user.
DBUS_PRIVATE_EXPORT void _dbus_log(DBusSystemLogSeverity severity, const char *msg,...)
Log a message to the system log file (e.g.
dbus_bool_t _dbus_windows_user_is_process_owner(const char *windows_sid)
Checks to see if the Windows user SID matches the owner of the process.
dbus_bool_t _dbus_parse_unix_group_from_config(const DBusString *groupname, dbus_gid_t *gid_p)
Parse a UNIX group from the bus config file.
int _dbus_listen_tcp_socket(const char *host, const char *port, const char *family, DBusString *retport, const char **retfamily, DBusSocket **fds_p, DBusError *error)
Creates a socket and binds it to the given path, then listens on the socket.
void _dbus_threads_unlock_platform_specific(void)
Undo _dbus_threads_lock_platform_specific().
dbus_bool_t _dbus_send_credentials_socket(DBusSocket server_fd, DBusError *error)
Sends a single nul byte with our UNIX credentials as ancillary data.
dbus_bool_t _dbus_unix_groups_from_uid(dbus_uid_t uid, dbus_gid_t **group_ids, int *n_group_ids, DBusError *error)
Gets all groups corresponding to the given UNIX user ID.
DBUS_PRIVATE_EXPORT dbus_uid_t _dbus_getuid(void)
Gets our UID.
dbus_bool_t _dbus_credentials_add_from_current_process(DBusCredentials *credentials)
Adds the most important credentials of the current process (the uid and pid) to the passed-in credent...
void _dbus_daemon_report_stopping(void)
Report to a service manager that the daemon calling this function is shutting down.
DBUS_PRIVATE_EXPORT void _dbus_atomic_set_zero(DBusAtomic *atomic)
Atomically set the value of an integer to 0.
DBUS_PRIVATE_EXPORT dbus_int32_t _dbus_atomic_inc(DBusAtomic *atomic)
Atomically increments an integer.
dbus_bool_t _dbus_generate_random_bytes(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of securely random bytes, using the best mechanism we can come up with.
DBUS_PRIVATE_EXPORT int _dbus_printf_string_upper_bound(const char *format, va_list args)
Measure the length of the given format string and arguments, not including the terminating nul.
DBUS_PRIVATE_EXPORT void _dbus_get_monotonic_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_delete_directory(const DBusString *filename, DBusError *error)
Removes a directory; Directory must be empty.
DBUS_PRIVATE_EXPORT const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
DBUS_PRIVATE_EXPORT void _dbus_get_real_time(long *tv_sec, long *tv_usec)
Get current time, as in gettimeofday().
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
dbus_bool_t _dbus_directory_get_next_file(DBusDirIter *iter, DBusString *filename, DBusError *error)
Get next file in the directory.
DBUS_PRIVATE_EXPORT int _dbus_poll(DBusPollFD *fds, int n_fds, int timeout_milliseconds)
Wrapper for poll().
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_generate_random_ascii(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of random bytes, where the bytes are chosen from the alphanumeric ASCII su...
dbus_bool_t _dbus_get_autolaunch_address(const char *scope, DBusString *address, DBusError *error)
Returns the address of a new session bus.
int _dbus_write_socket_two(DBusSocket fd, const DBusString *buffer1, int start1, int len1, const DBusString *buffer2, int start2, int len2)
Like _dbus_write_two() but only works on sockets and is thus available on Windows.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
dbus_bool_t _dbus_become_daemon(const DBusString *pidfile, DBusPipe *print_pid_pipe, DBusError *error, dbus_bool_t keep_umask)
Does the chdir, fork, setsid, etc.
dbus_bool_t _dbus_split_paths_and_append(DBusString *dirs, const char *suffix, DBusList **dir_list)
Split paths into a list of char strings.
DBUS_PRIVATE_EXPORT void _dbus_print_backtrace(void)
On GNU libc systems, print a crude backtrace to stderr.
DBUS_PRIVATE_EXPORT void _dbus_init_system_log(const char *tag, DBusLogFlags flags)
Initialize the system log.
dbus_bool_t _dbus_replace_install_prefix(DBusString *path)
Replace the DBUS_PREFIX in the given path, in-place, by the current D-Bus installation directory.
dbus_bool_t _dbus_lookup_session_address(dbus_bool_t *supported, DBusString *address, DBusError *error)
Determines the address of the session bus by querying a platform-specific method.
DBusSocket _dbus_accept(DBusSocket listen_fd)
Accepts a connection on a listening socket.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_append_user_from_current_process(DBusString *str)
Append to the string the identity we would like to have when we authenticate, on UNIX this is the cur...
DBUS_PRIVATE_EXPORT void _dbus_flush_caches(void)
Called when the bus daemon is signaled to reload its configuration; any caches should be nuked.
dbus_bool_t _dbus_get_is_errno_eintr(int e)
See if errno is EINTR.
dbus_bool_t _dbus_threads_init_platform_specific(void)
Initialize threads as in dbus_threads_init_default(), appropriately for the platform.
dbus_bool_t _dbus_unix_user_is_at_console(dbus_uid_t uid, DBusError *error)
Checks to see if the UNIX user ID is at the console.
void _dbus_set_errno_to_zero(void)
Assign 0 to the global errno variable.
DBUS_PRIVATE_EXPORT const char * _dbus_get_tmpdir(void)
Gets the temporary files directory by inspecting the environment variables TMPDIR,...
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_ensure_directory(const DBusString *filename, DBusError *error)
Creates a directory; succeeds if the directory is created or already existed.
dbus_bool_t _dbus_get_is_errno_enomem(int e)
See if errno is ENOMEM.
dbus_bool_t _dbus_string_get_dirname(const DBusString *filename, DBusString *dirname)
Get the directory name from a complete filename.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_path_is_absolute(const DBusString *filename)
Checks whether the filename is an absolute path.
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_create_directory(const DBusString *filename, DBusError *error)
directory interface
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition dbus-types.h:35
An atomic integer safe to increment or decrement from multiple threads.
volatile dbus_int32_t value
Value of the atomic integer.
Internals of directory iterator.
Object representing an exception.
Definition dbus-errors.h:49
A node in a linked list.
Definition dbus-list.h:35
short events
Events to poll for.
short revents
Events that occurred.
DBusPollable fd
File descriptor.
Socket interface.
Portable struct with stat() results.
unsigned long nlink
Number of hard links.
unsigned long size
Size of file.
dbus_uid_t uid
User owning file.
unsigned long mode
File mode.
dbus_gid_t gid
Group owning file.
unsigned long atime
Access time.
unsigned long ctime
Creation time.
unsigned long mtime
Modify time.
A globally unique ID ; we have one for each DBusServer, and also one for each machine with libdbus in...