dbus/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 /* AIX sys/poll.h does #define events reqevents, and other
  52  * wonderousness, so must include sys/poll before declaring
  53  * DBusPollFD
  54  */
  55 #ifdef HAVE_POLL
  56 #include <sys/poll.h>
  57 #endif
  58
  59 #ifdef DBUS_WINCE
  60 /* Windows CE lacks some system functions (such as errno and clock).
  61    We bring them in here.  */
  62 #include "dbus-sysdeps-wince-glue.h"
  63 #endif
  64
  65 #ifdef DBUS_WIN
  66 #include <ws2tcpip.h>
  67 #endif
  68
  69 DBUS_BEGIN_DECLS
  70
  71 #ifdef DBUS_WIN
  72 #define _DBUS_PATH_SEPARATOR ";"
  73 #else
  74 #define _DBUS_PATH_SEPARATOR ":"
  75 #endif
  76
  77 /* Forward declarations */
  78
  79
  80 /** An opaque list type */
  81 typedef struct DBusList DBusList;
  82
  83 /** Object that contains a list of credentials such as UNIX or Windows user ID */
  84 typedef struct DBusCredentials DBusCredentials;
  85
  86 /** A wrapper around a pipe descriptor or handle */
  87 typedef struct DBusPipe DBusPipe;
  88
  89 /**
  90  * @addtogroup DBusSysdeps
  91  *
  92  * @{
  93  */
  94
  95 DBUS_PRIVATE_EXPORT
  96 void _dbus_abort (void) _DBUS_GNUC_NORETURN;
  97
  98 dbus_bool_t _dbus_check_setuid (void);
  99 DBUS_PRIVATE_EXPORT
 100 const char* _dbus_getenv (const char *varname);
 101 DBUS_PRIVATE_EXPORT
 102 dbus_bool_t _dbus_clearenv (void);
 103 char **     _dbus_get_environment (void);
 104
 105 /** A process ID */
 106 typedef unsigned long dbus_pid_t;
 107 /** A user ID */
 108 typedef unsigned long dbus_uid_t;
 109 /** A group ID */
 110 typedef unsigned long dbus_gid_t;
 111
 112 /** an invalid PID used to represent an uninitialized dbus_pid_t field */
 113 #define DBUS_PID_UNSET ((dbus_pid_t) -1)
 114 /** an invalid UID used to represent an uninitialized dbus_uid_t field */
 115 #define DBUS_UID_UNSET ((dbus_uid_t) -1)
 116 /** an invalid GID used to represent an uninitialized dbus_gid_t field */
 117 #define DBUS_GID_UNSET ((dbus_gid_t) -1)
 118
 119 /** an appropriate printf format for dbus_pid_t */
 120 #define DBUS_PID_FORMAT "%lu"
 121 /** an appropriate printf format for dbus_uid_t */
 122 #define DBUS_UID_FORMAT "%lu"
 123 /** an appropriate printf format for dbus_gid_t */
 124 #define DBUS_GID_FORMAT "%lu"
 125
 126 /**
 127  * Socket interface
 128  */
 129 #ifdef DBUS_WIN
 130
 131 typedef struct { SOCKET sock; } DBusSocket;
 132 # define DBUS_SOCKET_FORMAT "Iu"
 133 # define DBUS_SOCKET_INIT { INVALID_SOCKET }
 134
 135 static inline SOCKET
 136 _dbus_socket_printable (DBusSocket s) { return s.sock; }
 137
 138 static inline dbus_bool_t
 139 _dbus_socket_is_valid (DBusSocket s) { return s.sock != INVALID_SOCKET; }
 140
 141 static inline void
 142 _dbus_socket_invalidate (DBusSocket *s) { s->sock = INVALID_SOCKET; }
 143
 144 static inline int
 145 _dbus_socket_get_int (DBusSocket s) { return (int)s.sock; }
 146
 147 #else /* not DBUS_WIN */
 148
 149 typedef struct { int fd; } DBusSocket;
 150 # define DBUS_SOCKET_FORMAT "d"
 151 # define DBUS_SOCKET_INIT { -1 }
 152
 153 static inline int
 154 _dbus_socket_printable (DBusSocket s) { return s.fd; }
 155
 156 static inline dbus_bool_t
 157 _dbus_socket_is_valid (DBusSocket s) { return s.fd >= 0; }
 158
 159 static inline void
 160 _dbus_socket_invalidate (DBusSocket *s) { s->fd = -1; }
 161
 162 static inline int
 163 _dbus_socket_get_int (DBusSocket s) { return s.fd; }
 164
 165 #endif /* not DBUS_WIN */
 166
 167 static inline DBusSocket
 168 _dbus_socket_get_invalid (void)
 169 {
 170   DBusSocket s = DBUS_SOCKET_INIT;
 171
 172   return s;
 173 }
 174
 175 dbus_bool_t _dbus_set_socket_nonblocking (DBusSocket      fd,
 176                                           DBusError      *error);
 177
 178 DBUS_PRIVATE_EXPORT
 179 dbus_bool_t _dbus_close_socket     (DBusSocket        fd,
 180                                     DBusError        *error);
 181 DBUS_PRIVATE_EXPORT
 182 int         _dbus_read_socket      (DBusSocket        fd,
 183                                     DBusString       *buffer,
 184                                     int               count);
 185 DBUS_PRIVATE_EXPORT
 186 int         _dbus_write_socket     (DBusSocket        fd,
 187                                     const DBusString *buffer,
 188                                     int               start,
 189                                     int               len);
 190 int         _dbus_write_socket_two (DBusSocket        fd,
 191                                     const DBusString *buffer1,
 192                                     int               start1,
 193                                     int               len1,
 194                                     const DBusString *buffer2,
 195                                     int               start2,
 196                                     int               len2);
 197
 198 int _dbus_read_socket_with_unix_fds      (DBusSocket        fd,
 199                                           DBusString       *buffer,
 200                                           int               count,
 201                                           int              *fds,
 202                                           unsigned int     *n_fds);
 203 DBUS_PRIVATE_EXPORT
 204 int _dbus_write_socket_with_unix_fds     (DBusSocket        fd,
 205                                           const DBusString *buffer,
 206                                           int               start,
 207                                           int               len,
 208                                           const int        *fds,
 209                                           int               n_fds);
 210 int _dbus_write_socket_with_unix_fds_two (DBusSocket        fd,
 211                                           const DBusString *buffer1,
 212                                           int               start1,
 213                                           int               len1,
 214                                           const DBusString *buffer2,
 215                                           int               start2,
 216                                           int               len2,
 217                                           const int        *fds,
 218                                           int               n_fds);
 219
 220 DBusSocket _dbus_connect_tcp_socket  (const char     *host,
 221                                       const char     *port,
 222                                       const char     *family,
 223                                       DBusError      *error);
 224 DBusSocket _dbus_connect_tcp_socket_with_nonce  (const char     *host,
 225                                                  const char     *port,
 226                                                  const char     *family,
 227                                                  const char     *noncefile,
 228                                                  DBusError      *error);
 229 int _dbus_listen_tcp_socket   (const char     *host,
 230                                const char     *port,
 231                                const char     *family,
 232                                DBusString     *retport,
 233                                DBusSocket    **fds_p,
 234                                DBusError      *error);
 235 DBusSocket _dbus_accept       (DBusSocket      listen_fd);
 236
 237 dbus_bool_t _dbus_read_credentials_socket (DBusSocket        client_fd,
 238                                            DBusCredentials  *credentials,
 239                                            DBusError        *error);
 240 dbus_bool_t _dbus_send_credentials_socket (DBusSocket       server_fd,
 241                                            DBusError       *error);
 242
 243 dbus_bool_t _dbus_credentials_add_from_user            (DBusCredentials  *credentials,
 244                                                         const DBusString *username);
 245 dbus_bool_t _dbus_credentials_add_from_current_process (DBusCredentials  *credentials);
 246 DBUS_PRIVATE_EXPORT
 247 dbus_bool_t _dbus_append_user_from_current_process     (DBusString        *str);
 248
 249 dbus_bool_t _dbus_parse_unix_user_from_config   (const DBusString  *username,
 250                                                  dbus_uid_t        *uid_p);
 251 dbus_bool_t _dbus_parse_unix_group_from_config  (const DBusString  *groupname,
 252                                                  dbus_gid_t        *gid_p);
 253 dbus_bool_t _dbus_unix_groups_from_uid          (dbus_uid_t         uid,
 254                                                  dbus_gid_t       **group_ids,
 255                                                  int               *n_group_ids);
 256 dbus_bool_t _dbus_unix_user_is_at_console       (dbus_uid_t         uid,
 257                                                  DBusError         *error);
 258 dbus_bool_t _dbus_unix_user_is_process_owner    (dbus_uid_t         uid);
 259 dbus_bool_t _dbus_windows_user_is_process_owner (const char        *windows_sid);
 260
 261 dbus_bool_t _dbus_append_keyring_directory_for_credentials (DBusString      *directory,
 262                                                             DBusCredentials *credentials);
 263
 264 dbus_bool_t _dbus_daemon_is_session_bus_address_published (const char *scope);
 265
 266 dbus_bool_t _dbus_daemon_publish_session_bus_address (const char* address, const char* shm_name);
 267
 268 void _dbus_daemon_unpublish_session_bus_address (void);
 269
 270 dbus_bool_t _dbus_socket_can_pass_unix_fd(DBusSocket fd);
 271
 272 /** Opaque type representing an atomically-modifiable integer
 273  * that can be used from multiple threads.
 274  */
 275 typedef struct DBusAtomic DBusAtomic;
 276
 277 /**
 278  * An atomic integer safe to increment or decrement from multiple threads.
 279  */
 280 struct DBusAtomic
 281 {
 282 #ifdef DBUS_WIN
 283   volatile long value; /**< Value of the atomic integer. */
 284 #else
 285   volatile dbus_int32_t value; /**< Value of the atomic integer. */
 286 #endif
 287 };
 288
 289 /* The value we get from autofoo is in the form of a cpp expression;
 290  * convert that to a conventional defined/undef switch. (We can't get
 291  * the conventional defined/undef because of multiarch builds only running
 292  * ./configure once, on Darwin.) */
 293 #if DBUS_HAVE_ATOMIC_INT_COND
 294 #   define DBUS_HAVE_ATOMIC_INT 1
 295 #else
 296 #   undef DBUS_HAVE_ATOMIC_INT
 297 #endif
 298
 299 DBUS_PRIVATE_EXPORT
 300 dbus_int32_t _dbus_atomic_inc (DBusAtomic *atomic);
 301 DBUS_PRIVATE_EXPORT
 302 dbus_int32_t _dbus_atomic_dec (DBusAtomic *atomic);
 303 DBUS_PRIVATE_EXPORT
 304 dbus_int32_t _dbus_atomic_get (DBusAtomic *atomic);
 305
 306 #ifdef DBUS_WIN
 307
 308 /* On Windows, you can only poll sockets. We emulate Unix poll() using
 309  * select(), so it doesn't matter what precise type we put in DBusPollFD;
 310  * use DBusSocket so that the compiler can check we are doing it right.
 311  */
 312 typedef DBusSocket DBusPollable;
 313 # define DBUS_POLLABLE_FORMAT "Iu"
 314
 315 static inline DBusPollable
 316 _dbus_socket_get_pollable (DBusSocket s) { return s; }
 317
 318 static inline SOCKET
 319 _dbus_pollable_printable (DBusPollable p) { return p.sock; }
 320
 321 static inline dbus_bool_t
 322 _dbus_pollable_is_valid (DBusPollable p) { return _dbus_socket_is_valid (p); }
 323
 324 static inline void
 325 _dbus_pollable_invalidate (DBusPollable *p) { _dbus_socket_invalidate (p); }
 326
 327 static inline dbus_bool_t
 328 _dbus_pollable_equals (DBusPollable a, DBusPollable b) { return a.sock == b.sock; }
 329
 330 #else /* !DBUS_WIN */
 331
 332 /* On Unix, you can poll sockets, pipes, etc., and we must put exactly
 333  * "int" in DBusPollFD because we're relying on its layout exactly matching
 334  * struct pollfd. (This is silly, and one day we should use a better
 335  * abstraction.)
 336  */
 337 typedef int DBusPollable;
 338 # define DBUS_POLLABLE_FORMAT "d"
 339
 340 static inline DBusPollable
 341 _dbus_socket_get_pollable (DBusSocket s) { return s.fd; }
 342
 343 static inline int
 344 _dbus_pollable_printable (DBusPollable p) { return p; }
 345
 346 static inline dbus_bool_t
 347 _dbus_pollable_is_valid (DBusPollable p) { return p >= 0; }
 348
 349 static inline void
 350 _dbus_pollable_invalidate (DBusPollable *p) { *p = -1; }
 351
 352 static inline dbus_bool_t
 353 _dbus_pollable_equals (DBusPollable a, DBusPollable b) { return a == b; }
 354
 355 #endif /* !DBUS_WIN */
 356
 357 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
 358 /**
 359  * A portable struct pollfd wrapper, or an emulation of struct pollfd
 360  * on platforms where poll() is missing or broken.
 361  */
 362 typedef struct pollfd DBusPollFD;
 363
 364 /** There is data to read */
 365 #define _DBUS_POLLIN      POLLIN
 366 /** There is urgent data to read */
 367 #define _DBUS_POLLPRI     POLLPRI
 368 /** Writing now will not block */
 369 #define _DBUS_POLLOUT     POLLOUT
 370 /** Error condition */
 371 #define _DBUS_POLLERR     POLLERR
 372 /** Hung up */
 373 #define _DBUS_POLLHUP     POLLHUP
 374 /** Invalid request: fd not open */
 375 #define _DBUS_POLLNVAL    POLLNVAL
 376 #else
 377 /* Emulate poll() via select(). Because we aren't really going to call
 378  * poll(), any similarly-shaped struct is acceptable, and any power of 2
 379  * will do for the events/revents; these values happen to match Linux
 380  * and *BSD. */
 381 typedef struct
 382 {
 383   DBusPollable fd;   /**< File descriptor */
 384   short events;      /**< Events to poll for */
 385   short revents;     /**< Events that occurred */
 386 } DBusPollFD;
 387
 388 /** There is data to read */
 389 #define _DBUS_POLLIN      0x0001
 390 /** There is urgent data to read */
 391 #define _DBUS_POLLPRI     0x0002
 392 /** Writing now will not block */
 393 #define _DBUS_POLLOUT     0x0004
 394 /** Error condition */
 395 #define _DBUS_POLLERR     0x0008
 396 /** Hung up */
 397 #define _DBUS_POLLHUP     0x0010
 398 /** Invalid request: fd not open */
 399 #define _DBUS_POLLNVAL    0x0020
 400 #endif
 401
 402 DBUS_PRIVATE_EXPORT
 403 int _dbus_poll (DBusPollFD *fds,
 404                 int         n_fds,
 405                 int         timeout_milliseconds);
 406
 407 DBUS_PRIVATE_EXPORT
 408 void _dbus_sleep_milliseconds (int milliseconds);
 409
 410 DBUS_PRIVATE_EXPORT
 411 void _dbus_get_monotonic_time (long *tv_sec,
 412                                long *tv_usec);
 413
 414 DBUS_PRIVATE_EXPORT
 415 void _dbus_get_real_time (long *tv_sec,
 416                           long *tv_usec);
 417
 418 /**
 419  * directory interface
 420  */
 421 DBUS_PRIVATE_EXPORT
 422 dbus_bool_t    _dbus_create_directory        (const DBusString *filename,
 423                                               DBusError        *error);
 424 DBUS_PRIVATE_EXPORT
 425 dbus_bool_t    _dbus_delete_directory        (const DBusString *filename,
 426                                               DBusError        *error);
 427
 428 DBUS_PRIVATE_EXPORT
 429 dbus_bool_t _dbus_concat_dir_and_file (DBusString       *dir,
 430                                        const DBusString *next_component);
 431 dbus_bool_t _dbus_string_get_dirname  (const DBusString *filename,
 432                                        DBusString       *dirname);
 433 DBUS_PRIVATE_EXPORT
 434 dbus_bool_t _dbus_path_is_absolute    (const DBusString *filename);
 435
 436 dbus_bool_t _dbus_get_standard_session_servicedirs (DBusList **dirs);
 437 dbus_bool_t _dbus_get_standard_system_servicedirs (DBusList **dirs);
 438
 439 dbus_bool_t _dbus_get_system_config_file  (DBusString *str);
 440 dbus_bool_t _dbus_get_session_config_file (DBusString *str);
 441
 442 /** Opaque type for reading a directory listing */
 443 typedef struct DBusDirIter DBusDirIter;
 444
 445 DBusDirIter* _dbus_directory_open          (const DBusString *filename,
 446                                             DBusError        *error);
 447 dbus_bool_t  _dbus_directory_get_next_file (DBusDirIter      *iter,
 448                                             DBusString       *filename,
 449                                             DBusError        *error);
 450 void         _dbus_directory_close         (DBusDirIter      *iter);
 451
 452 dbus_bool_t  _dbus_check_dir_is_private_to_user    (DBusString *dir,
 453                                                     DBusError *error);
 454
 455 DBUS_PRIVATE_EXPORT
 456 const char* _dbus_get_tmpdir      (void);
 457
 458 /**
 459  * Random numbers
 460  */
 461 _DBUS_GNUC_WARN_UNUSED_RESULT
 462 dbus_bool_t _dbus_generate_random_bytes_buffer (char       *buffer,
 463                                                 int         n_bytes,
 464                                                 DBusError  *error);
 465 dbus_bool_t _dbus_generate_random_bytes        (DBusString *str,
 466                                                 int         n_bytes,
 467                                                 DBusError  *error);
 468 DBUS_PRIVATE_EXPORT
 469 dbus_bool_t _dbus_generate_random_ascii        (DBusString *str,
 470                                                 int         n_bytes,
 471                                                 DBusError  *error);
 472
 473 DBUS_PRIVATE_EXPORT
 474 const char* _dbus_error_from_errno (int error_number);
 475 DBUS_PRIVATE_EXPORT
 476 const char* _dbus_error_from_system_errno (void);
 477
 478 int         _dbus_save_socket_errno                  (void);
 479 void        _dbus_restore_socket_errno               (int saved_errno);
 480 void        _dbus_set_errno_to_zero                  (void);
 481 dbus_bool_t _dbus_get_is_errno_eagain_or_ewouldblock (int e);
 482 dbus_bool_t _dbus_get_is_errno_enomem                (int e);
 483 dbus_bool_t _dbus_get_is_errno_eintr                 (int e);
 484 dbus_bool_t _dbus_get_is_errno_epipe                 (int e);
 485 dbus_bool_t _dbus_get_is_errno_etoomanyrefs          (int e);
 486 DBUS_PRIVATE_EXPORT
 487 const char* _dbus_strerror_from_errno                (void);
 488
 489 void _dbus_disable_sigpipe (void);
 490
 491 DBUS_PRIVATE_EXPORT
 492 void _dbus_exit (int code) _DBUS_GNUC_NORETURN;
 493
 494 DBUS_PRIVATE_EXPORT
 495 int _dbus_printf_string_upper_bound (const char *format,
 496                                      va_list args);
 497
 498 #ifdef DBUS_ENABLE_VERBOSE_MODE
 499 DBUS_PRIVATE_EXPORT
 500 void _dbus_print_thread (void);
 501 #endif
 502
 503 /**
 504  * Portable struct with stat() results
 505  */
 506 typedef struct
 507 {
 508   unsigned long mode;  /**< File mode */
 509   unsigned long nlink; /**< Number of hard links */
 510   dbus_uid_t    uid;   /**< User owning file */
 511   dbus_gid_t    gid;   /**< Group owning file */
 512   unsigned long size;  /**< Size of file */
 513   unsigned long atime; /**< Access time */
 514   unsigned long mtime; /**< Modify time */
 515   unsigned long ctime; /**< Creation time */
 516 } DBusStat;
 517
 518 dbus_bool_t _dbus_stat             (const DBusString *filename,
 519                                     DBusStat         *statbuf,
 520                                     DBusError        *error);
 521 DBUS_PRIVATE_EXPORT
 522 dbus_bool_t _dbus_socketpair (DBusSocket       *fd1,
 523                               DBusSocket       *fd2,
 524                               dbus_bool_t       blocking,
 525                               DBusError        *error);
 526
 527 DBUS_PRIVATE_EXPORT
 528 void        _dbus_print_backtrace  (void);
 529
 530 dbus_bool_t _dbus_become_daemon   (const DBusString *pidfile,
 531                                    DBusPipe         *print_pid_pipe,
 532                                    DBusError        *error,
 533                                    dbus_bool_t       keep_umask);
 534
 535 dbus_bool_t _dbus_verify_daemon_user    (const char *user);
 536 dbus_bool_t _dbus_change_to_daemon_user (const char *user,
 537                                          DBusError  *error);
 538
 539 dbus_bool_t _dbus_write_pid_to_file_and_pipe (const DBusString *pidfile,
 540                                               DBusPipe         *print_pid_pipe,
 541                                               dbus_pid_t        pid_to_write,
 542                                               DBusError        *error);
 543
 544 dbus_bool_t _dbus_command_for_pid (unsigned long  pid,
 545                                    DBusString    *str,
 546                                    int            max_len,
 547                                    DBusError     *error);
 548
 549 /** A UNIX signal handler */
 550 typedef void (* DBusSignalHandler) (int sig);
 551
 552 void _dbus_set_signal_handler (int               sig,
 553                                DBusSignalHandler handler);
 554
 555 dbus_bool_t _dbus_user_at_console (const char *username,
 556                                    DBusError  *error);
 557
 558 void _dbus_init_system_log (dbus_bool_t is_daemon);
 559
 560 typedef enum {
 561   DBUS_SYSTEM_LOG_INFO,
 562   DBUS_SYSTEM_LOG_WARNING,
 563   DBUS_SYSTEM_LOG_SECURITY,
 564   DBUS_SYSTEM_LOG_FATAL
 565 } DBusSystemLogSeverity;
 566
 567 void _dbus_system_log (DBusSystemLogSeverity severity, const char *msg, ...) _DBUS_GNUC_PRINTF (2, 3);
 568 void _dbus_system_logv (DBusSystemLogSeverity severity, const char *msg, va_list args);
 569
 570 /* Define DBUS_VA_COPY() to do the right thing for copying va_list variables.
 571  * config.h may have already defined DBUS_VA_COPY as va_copy or __va_copy.
 572  */
 573 #if !defined (DBUS_VA_COPY)
 574 #  if defined (__GNUC__) && defined (__PPC__) && (defined (_CALL_SYSV) || defined (_WIN32))
 575 #    define DBUS_VA_COPY(ap1, ap2)   (*(ap1) = *(ap2))
 576 #  elif defined (DBUS_VA_COPY_AS_ARRAY)
 577 #    define DBUS_VA_COPY(ap1, ap2)   memcpy ((ap1), (ap2), sizeof (va_list))
 578 #  else /* va_list is a pointer */
 579 #    define DBUS_VA_COPY(ap1, ap2)   ((ap1) = (ap2))
 580 #  endif /* va_list is a pointer */
 581 #endif /* !DBUS_VA_COPY */
 582
 583
 584 /**
 585  * Casts a primitive C type to a byte array and then indexes
 586  * a particular byte of the array.
 587  */
 588 #define _DBUS_BYTE_OF_PRIMITIVE(p, i) \
 589     (((const char*)&(p))[(i)])
 590 /** On x86 there is an 80-bit FPU, and if you do "a == b" it may have a
 591  * or b in an 80-bit register, thus failing to compare the two 64-bit
 592  * doubles for bitwise equality. So this macro compares the two doubles
 593  * bitwise.
 594  */
 595 #define _DBUS_DOUBLES_BITWISE_EQUAL(a, b)                                       \
 596      (_DBUS_BYTE_OF_PRIMITIVE (a, 0) == _DBUS_BYTE_OF_PRIMITIVE (b, 0) &&       \
 597       _DBUS_BYTE_OF_PRIMITIVE (a, 1) == _DBUS_BYTE_OF_PRIMITIVE (b, 1) &&       \
 598       _DBUS_BYTE_OF_PRIMITIVE (a, 2) == _DBUS_BYTE_OF_PRIMITIVE (b, 2) &&       \
 599       _DBUS_BYTE_OF_PRIMITIVE (a, 3) == _DBUS_BYTE_OF_PRIMITIVE (b, 3) &&       \
 600       _DBUS_BYTE_OF_PRIMITIVE (a, 4) == _DBUS_BYTE_OF_PRIMITIVE (b, 4) &&       \
 601       _DBUS_BYTE_OF_PRIMITIVE (a, 5) == _DBUS_BYTE_OF_PRIMITIVE (b, 5) &&       \
 602       _DBUS_BYTE_OF_PRIMITIVE (a, 6) == _DBUS_BYTE_OF_PRIMITIVE (b, 6) &&       \
 603       _DBUS_BYTE_OF_PRIMITIVE (a, 7) == _DBUS_BYTE_OF_PRIMITIVE (b, 7))
 604
 605 dbus_bool_t _dbus_get_autolaunch_address (const char *scope,
 606                                           DBusString *address,
 607                                                               DBusError  *error);
 608
 609 dbus_bool_t _dbus_lookup_session_address (dbus_bool_t *supported,
 610                                           DBusString  *address,
 611                                           DBusError   *error);
 612
 613 /** Type representing a universally unique ID
 614  * @todo rename to UUID instead of GUID
 615  */
 616 typedef union DBusGUID DBusGUID;
 617
 618 dbus_bool_t _dbus_read_local_machine_uuid   (DBusGUID         *machine_id,
 619                                              dbus_bool_t       create_if_not_found,
 620                                              DBusError        *error);
 621
 622 /**
 623  * Initialize threads as in dbus_threads_init_default(), appropriately
 624  * for the platform.
 625  * @returns #FALSE if no memory
 626  */
 627 dbus_bool_t _dbus_threads_init_platform_specific (void);
 628
 629 /**
 630  * Lock a static mutex used to protect _dbus_threads_init_platform_specific().
 631  */
 632 void _dbus_threads_lock_platform_specific (void);
 633
 634 /**
 635  * Undo _dbus_threads_lock_platform_specific().
 636  */
 637 void _dbus_threads_unlock_platform_specific (void);
 638
 639 DBUS_PRIVATE_EXPORT
 640 dbus_bool_t _dbus_split_paths_and_append (DBusString *dirs,
 641                                           const char *suffix,
 642                                           DBusList **dir_list);
 643
 644 unsigned long _dbus_pid_for_log (void);
 645
 646 /* FIXME move back to dbus-sysdeps-unix.h probably -
 647  * the PID file handling just needs a little more abstraction
 648  * in the bus daemon first.
 649  */
 650 DBUS_PRIVATE_EXPORT
 651 dbus_pid_t    _dbus_getpid (void);
 652
 653 DBUS_PRIVATE_EXPORT
 654 dbus_uid_t    _dbus_getuid (void);
 655
 656 dbus_bool_t _dbus_change_to_daemon_user (const char *user,
 657                                          DBusError  *error);
 658
 659 DBUS_PRIVATE_EXPORT
 660 void _dbus_flush_caches (void);
 661
 662 dbus_bool_t _dbus_replace_install_prefix (DBusString *path);
 663
 664 /* Do not set this too high: it is a denial-of-service risk.
 665  * See <https://bugs.freedesktop.org/show_bug.cgi?id=82820>
 666  *
 667  * (This needs to be in the non-Unix-specific header so that
 668  * the config-parser can use it.)
 669  */
 670 #define DBUS_DEFAULT_MESSAGE_UNIX_FDS 16
 671
 672 typedef struct DBusRLimit DBusRLimit;
 673
 674 DBusRLimit     *_dbus_rlimit_save_fd_limit                 (DBusError    *error);
 675 dbus_bool_t     _dbus_rlimit_raise_fd_limit_if_privileged  (unsigned int  desired,
 676                                                             DBusError    *error);
 677 dbus_bool_t     _dbus_rlimit_restore_fd_limit              (DBusRLimit   *saved,
 678                                                             DBusError    *error);
 679 void            _dbus_rlimit_free                          (DBusRLimit   *lim);
 680
 681 /** @} */
 682
 683 DBUS_END_DECLS
 684
 685
 686 #ifdef DBUS_WIN
 687 #include "dbus-sysdeps-win.h"
 688 #endif
 689
 690 #endif /* DBUS_SYSDEPS_H */