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