dbus/dbus-sysdeps.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* dbus-sysdeps.c 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 #include "dbus-internals.h"
  26 #include "dbus-sysdeps.h"
  27 #include "dbus-threads.h"
  28 #include "dbus-protocol.h"
  29 #include "dbus-test.h"
  30 #include <sys/types.h>
  31 #include <stdlib.h>
  32 #include <string.h>
  33 #include <signal.h>
  34 #include <unistd.h>
  35 #include <stdio.h>
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <sys/socket.h>
  39 #include <dirent.h>
  40 #include <sys/un.h>
  41 #include <pwd.h>
  42 #include <time.h>
  43 #include <locale.h>
  44 #include <sys/time.h>
  45 #include <sys/stat.h>
  46 #include <sys/wait.h>
  47 #include <netinet/in.h>
  48 #include <netdb.h>
  49 #include <grp.h>
  50
  51 #ifdef HAVE_WRITEV
  52 #include <sys/uio.h>
  53 #endif
  54 #ifdef HAVE_POLL
  55 #include <sys/poll.h>
  56 #endif
  57 #ifdef HAVE_BACKTRACE
  58 #include <execinfo.h>
  59 #endif
  60
  61
  62 #ifndef O_BINARY
  63 #define O_BINARY 0
  64 #endif
  65
  66 #ifndef HAVE_SOCKLEN_T
  67 #define socklen_t int
  68 #endif
  69
  70 /**
  71  * @addtogroup DBusInternalsUtils
  72  * @{
  73  */
  74 /**
  75  * Aborts the program with SIGABRT (dumping core).
  76  */
  77 void
  78 _dbus_abort (void)
  79 {
  80 #ifdef DBUS_ENABLE_VERBOSE_MODE
  81   const char *s;
  82   s = _dbus_getenv ("DBUS_PRINT_BACKTRACE");
  83   if (s && *s)
  84     _dbus_print_backtrace ();
  85 #endif
  86   abort ();
  87   _exit (1); /* in case someone manages to ignore SIGABRT */
  88 }
  89
  90 /**
  91  * Wrapper for setenv(). If the value is #NULL, unsets
  92  * the environment variable.
  93  *
  94  * @todo if someone can verify it's safe, we could avoid the
  95  * memleak when doing an unset.
  96  *
  97  * @param varname name of environment variable
  98  * @param value value of environment variable
  99  * @returns #TRUE on success.
 100  */
 101 dbus_bool_t
 102 _dbus_setenv (const char *varname,
 103               const char *value)
 104 {
 105   _dbus_assert (varname != NULL);
 106
 107   if (value == NULL)
 108     {
 109 #ifdef HAVE_UNSETENV
 110       unsetenv (varname);
 111       return TRUE;
 112 #else
 113       char *putenv_value;
 114       size_t len;
 115
 116       len = strlen (varname);
 117
 118       /* Use system malloc to avoid memleaks that dbus_malloc
 119        * will get upset about.
 120        */
 121
 122       putenv_value = malloc (len + 1);
 123       if (putenv_value == NULL)
 124         return FALSE;
 125
 126       strcpy (putenv_value, varname);
 127
 128       return (putenv (putenv_value) == 0);
 129 #endif
 130     }
 131   else
 132     {
 133 #ifdef HAVE_SETENV
 134       return (setenv (varname, value, TRUE) == 0);
 135 #else
 136       char *putenv_value;
 137       size_t len;
 138       size_t varname_len;
 139       size_t value_len;
 140
 141       varname_len = strlen (varname);
 142       value_len = strlen (value);
 143
 144       len = varname_len + value_len + 1 /* '=' */ ;
 145
 146       /* Use system malloc to avoid memleaks that dbus_malloc
 147        * will get upset about.
 148        */
 149
 150       putenv_value = malloc (len + 1);
 151       if (putenv_value == NULL)
 152         return FALSE;
 153
 154       strcpy (putenv_value, varname);
 155       strcpy (putenv_value + varname_len, "=");
 156       strcpy (putenv_value + varname_len + 1, value);
 157
 158       return (putenv (putenv_value) == 0);
 159 #endif
 160     }
 161 }
 162
 163 /**
 164  * Wrapper for getenv().
 165  *
 166  * @param varname name of environment variable
 167  * @returns value of environment variable or #NULL if unset
 168  */
 169 const char*
 170 _dbus_getenv (const char *varname)
 171 {
 172   return getenv (varname);
 173 }
 174
 175 /**
 176  * Thin wrapper around the read() system call that appends
 177  * the data it reads to the DBusString buffer. It appends
 178  * up to the given count, and returns the same value
 179  * and same errno as read(). The only exception is that
 180  * _dbus_read() handles EINTR for you. _dbus_read() can
 181  * return ENOMEM, even though regular UNIX read doesn't.
 182  *
 183  * @param fd the file descriptor to read from
 184  * @param buffer the buffer to append data to
 185  * @param count the amount of data to read
 186  * @returns the number of bytes read or -1
 187  */
 188 int
 189 _dbus_read (int               fd,
 190             DBusString       *buffer,
 191             int               count)
 192 {
 193   int bytes_read;
 194   int start;
 195   char *data;
 196
 197   _dbus_assert (count >= 0);
 198
 199   start = _dbus_string_get_length (buffer);
 200
 201   if (!_dbus_string_lengthen (buffer, count))
 202     {
 203       errno = ENOMEM;
 204       return -1;
 205     }
 206
 207   data = _dbus_string_get_data_len (buffer, start, count);
 208
 209  again:
 210
 211   bytes_read = read (fd, data, count);
 212
 213   if (bytes_read < 0)
 214     {
 215       if (errno == EINTR)
 216         goto again;
 217       else
 218         {
 219           /* put length back (note that this doesn't actually realloc anything) */
 220           _dbus_string_set_length (buffer, start);
 221           return -1;
 222         }
 223     }
 224   else
 225     {
 226       /* put length back (doesn't actually realloc) */
 227       _dbus_string_set_length (buffer, start + bytes_read);
 228
 229 #if 0
 230       if (bytes_read > 0)
 231         _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
 232 #endif
 233
 234       return bytes_read;
 235     }
 236 }
 237
 238 /**
 239  * Thin wrapper around the write() system call that writes a part of a
 240  * DBusString and handles EINTR for you.
 241  *
 242  * @param fd the file descriptor to write
 243  * @param buffer the buffer to write data from
 244  * @param start the first byte in the buffer to write
 245  * @param len the number of bytes to try to write
 246  * @returns the number of bytes written or -1 on error
 247  */
 248 int
 249 _dbus_write (int               fd,
 250              const DBusString *buffer,
 251              int               start,
 252              int               len)
 253 {
 254   const char *data;
 255   int bytes_written;
 256
 257   data = _dbus_string_get_const_data_len (buffer, start, len);
 258
 259  again:
 260
 261   bytes_written = write (fd, data, len);
 262
 263   if (bytes_written < 0 && errno == EINTR)
 264     goto again;
 265
 266 #if 0
 267   if (bytes_written > 0)
 268     _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
 269 #endif
 270
 271   return bytes_written;
 272 }
 273
 274 /**
 275  * Like _dbus_write() but will use writev() if possible
 276  * to write both buffers in sequence. The return value
 277  * is the number of bytes written in the first buffer,
 278  * plus the number written in the second. If the first
 279  * buffer is written successfully and an error occurs
 280  * writing the second, the number of bytes in the first
 281  * is returned (i.e. the error is ignored), on systems that
 282  * don't have writev. Handles EINTR for you.
 283  * The second buffer may be #NULL.
 284  *
 285  * @param fd the file descriptor
 286  * @param buffer1 first buffer
 287  * @param start1 first byte to write in first buffer
 288  * @param len1 number of bytes to write from first buffer
 289  * @param buffer2 second buffer, or #NULL
 290  * @param start2 first byte to write in second buffer
 291  * @param len2 number of bytes to write in second buffer
 292  * @returns total bytes written from both buffers, or -1 on error
 293  */
 294 int
 295 _dbus_write_two (int               fd,
 296                  const DBusString *buffer1,
 297                  int               start1,
 298                  int               len1,
 299                  const DBusString *buffer2,
 300                  int               start2,
 301                  int               len2)
 302 {
 303   _dbus_assert (buffer1 != NULL);
 304   _dbus_assert (start1 >= 0);
 305   _dbus_assert (start2 >= 0);
 306   _dbus_assert (len1 >= 0);
 307   _dbus_assert (len2 >= 0);
 308
 309 #ifdef HAVE_WRITEV
 310   {
 311     struct iovec vectors[2];
 312     const char *data1;
 313     const char *data2;
 314     int bytes_written;
 315
 316     data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
 317
 318     if (buffer2 != NULL)
 319       data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
 320     else
 321       {
 322         data2 = NULL;
 323         start2 = 0;
 324         len2 = 0;
 325       }
 326
 327     vectors[0].iov_base = (char*) data1;
 328     vectors[0].iov_len = len1;
 329     vectors[1].iov_base = (char*) data2;
 330     vectors[1].iov_len = len2;
 331
 332   again:
 333
 334     bytes_written = writev (fd,
 335                             vectors,
 336                             data2 ? 2 : 1);
 337
 338     if (bytes_written < 0 && errno == EINTR)
 339       goto again;
 340
 341     return bytes_written;
 342   }
 343 #else /* HAVE_WRITEV */
 344   {
 345     int ret1;
 346
 347     ret1 = _dbus_write (fd, buffer1, start1, len1);
 348     if (ret1 == len1 && buffer2 != NULL)
 349       {
 350         ret2 = _dbus_write (fd, buffer2, start2, len2);
 351         if (ret2 < 0)
 352           ret2 = 0; /* we can't report an error as the first write was OK */
 353
 354         return ret1 + ret2;
 355       }
 356     else
 357       return ret1;
 358   }
 359 #endif /* !HAVE_WRITEV */
 360 }
 361
 362 #define _DBUS_MAX_SUN_PATH_LENGTH 99
 363
 364 /**
 365  * @def _DBUS_MAX_SUN_PATH_LENGTH
 366  *
 367  * Maximum length of the path to a UNIX domain socket,
 368  * sockaddr_un::sun_path member. POSIX requires that all systems
 369  * support at least 100 bytes here, including the nul termination.
 370  * We use 99 for the max value to allow for the nul.
 371  *
 372  * We could probably also do sizeof (addr.sun_path)
 373  * but this way we are the same on all platforms
 374  * which is probably a good idea.
 375  */
 376
 377 /**
 378  * Creates a socket and connects it to the UNIX domain socket at the
 379  * given path.  The connection fd is returned, and is set up as
 380  * nonblocking.
 381  *
 382  * Uses abstract sockets instead of filesystem-linked sockets if
 383  * requested (it's possible only on Linux; see "man 7 unix" on Linux).
 384  * On non-Linux abstract socket usage always fails.
 385  *
 386  * @param path the path to UNIX domain socket
 387  * @param abstract #TRUE to use abstract namespace
 388  * @param error return location for error code
 389  * @returns connection file descriptor or -1 on error
 390  */
 391 int
 392 _dbus_connect_unix_socket (const char     *path,
 393                            dbus_bool_t     abstract,
 394                            DBusError      *error)
 395 {
 396   int fd;
 397   struct sockaddr_un addr;
 398
 399   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 400
 401   _dbus_verbose ("connecting to unix socket %s abstract=%d\n",
 402                  path, abstract);
 403
 404   fd = socket (PF_UNIX, SOCK_STREAM, 0);
 405
 406   if (fd < 0)
 407     {
 408       dbus_set_error (error,
 409                       _dbus_error_from_errno (errno),
 410                       "Failed to create socket: %s",
 411                       _dbus_strerror (errno));
 412
 413       return -1;
 414     }
 415
 416   _DBUS_ZERO (addr);
 417   addr.sun_family = AF_UNIX;
 418
 419   if (abstract)
 420     {
 421 #ifdef HAVE_ABSTRACT_SOCKETS
 422       /* remember that abstract names aren't nul-terminated so we rely
 423        * on sun_path being filled in with zeroes above.
 424        */
 425       addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
 426       strncpy (&addr.sun_path[1], path, _DBUS_MAX_SUN_PATH_LENGTH - 2);
 427       /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
 428 #else /* HAVE_ABSTRACT_SOCKETS */
 429       dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
 430                       "Operating system does not support abstract socket namespace\n");
 431       close (fd);
 432       return -1;
 433 #endif /* ! HAVE_ABSTRACT_SOCKETS */
 434     }
 435   else
 436     {
 437       strncpy (addr.sun_path, path, _DBUS_MAX_SUN_PATH_LENGTH - 1);
 438     }
 439
 440   if (connect (fd, (struct sockaddr*) &addr, sizeof (addr)) < 0)
 441     {
 442       dbus_set_error (error,
 443                       _dbus_error_from_errno (errno),
 444                       "Failed to connect to socket %s: %s",
 445                       path, _dbus_strerror (errno));
 446
 447       close (fd);
 448       fd = -1;
 449
 450       return -1;
 451     }
 452
 453   if (!_dbus_set_fd_nonblocking (fd, error))
 454     {
 455       _DBUS_ASSERT_ERROR_IS_SET (error);
 456
 457       close (fd);
 458       fd = -1;
 459
 460       return -1;
 461     }
 462
 463   return fd;
 464 }
 465
 466 /**
 467  * Creates a socket and binds it to the given path,
 468  * then listens on the socket. The socket is
 469  * set to be nonblocking.
 470  *
 471  * Uses abstract sockets instead of filesystem-linked
 472  * sockets if requested (it's possible only on Linux;
 473  * see "man 7 unix" on Linux).
 474  * On non-Linux abstract socket usage always fails.
 475  *
 476  * @param path the socket name
 477  * @param abstract #TRUE to use abstract namespace
 478  * @param error return location for errors
 479  * @returns the listening file descriptor or -1 on error
 480  */
 481 int
 482 _dbus_listen_unix_socket (const char     *path,
 483                           dbus_bool_t     abstract,
 484                           DBusError      *error)
 485 {
 486   int listen_fd;
 487   struct sockaddr_un addr;
 488
 489   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 490
 491   _dbus_verbose ("listening on unix socket %s abstract=%d\n",
 492                  path, abstract);
 493
 494   listen_fd = socket (PF_UNIX, SOCK_STREAM, 0);
 495
 496   if (listen_fd < 0)
 497     {
 498       dbus_set_error (error, _dbus_error_from_errno (errno),
 499                       "Failed to create socket \"%s\": %s",
 500                       path, _dbus_strerror (errno));
 501       return -1;
 502     }
 503
 504   _DBUS_ZERO (addr);
 505   addr.sun_family = AF_UNIX;
 506
 507   if (abstract)
 508     {
 509 #ifdef HAVE_ABSTRACT_SOCKETS
 510       /* remember that abstract names aren't nul-terminated so we rely
 511        * on sun_path being filled in with zeroes above.
 512        */
 513       addr.sun_path[0] = '\0'; /* this is what says "use abstract" */
 514       strncpy (&addr.sun_path[1], path, _DBUS_MAX_SUN_PATH_LENGTH - 2);
 515       /* _dbus_verbose_bytes (addr.sun_path, sizeof (addr.sun_path)); */
 516 #else /* HAVE_ABSTRACT_SOCKETS */
 517       dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
 518                       "Operating system does not support abstract socket namespace\n");
 519       close (listen_fd);
 520       return -1;
 521 #endif /* ! HAVE_ABSTRACT_SOCKETS */
 522     }
 523   else
 524     {
 525       /* FIXME discussed security implications of this with Nalin,
 526        * and we couldn't think of where it would kick our ass, but
 527        * it still seems a bit sucky. It also has non-security suckage;
 528        * really we'd prefer to exit if the socket is already in use.
 529        * But there doesn't seem to be a good way to do this.
 530        *
 531        * Just to be extra careful, I threw in the stat() - clearly
 532        * the stat() can't *fix* any security issue, but it at least
 533        * avoids inadvertent/accidental data loss.
 534        */
 535       {
 536         struct stat sb;
 537
 538         if (stat (path, &sb) == 0 &&
 539             S_ISSOCK (sb.st_mode))
 540           unlink (path);
 541       }
 542
 543       strncpy (addr.sun_path, path, _DBUS_MAX_SUN_PATH_LENGTH - 1);
 544     }
 545
 546   if (bind (listen_fd, (struct sockaddr*) &addr, sizeof (addr)) < 0)
 547     {
 548       dbus_set_error (error, _dbus_error_from_errno (errno),
 549                       "Failed to bind socket \"%s\": %s",
 550                       path, _dbus_strerror (errno));
 551       close (listen_fd);
 552       return -1;
 553     }
 554
 555   if (listen (listen_fd, 30 /* backlog */) < 0)
 556     {
 557       dbus_set_error (error, _dbus_error_from_errno (errno),
 558                       "Failed to listen on socket \"%s\": %s",
 559                       path, _dbus_strerror (errno));
 560       close (listen_fd);
 561       return -1;
 562     }
 563
 564   if (!_dbus_set_fd_nonblocking (listen_fd, error))
 565     {
 566       _DBUS_ASSERT_ERROR_IS_SET (error);
 567       close (listen_fd);
 568       return -1;
 569     }
 570
 571   /* Try opening up the permissions, but if we can't, just go ahead
 572    * and continue, maybe it will be good enough.
 573    */
 574   if (!abstract && chmod (path, 0777) < 0)
 575     _dbus_warn ("Could not set mode 0777 on socket %s\n",
 576                 path);
 577
 578   return listen_fd;
 579 }
 580
 581 /**
 582  * Creates a socket and connects to a socket at the given host
 583  * and port. The connection fd is returned, and is set up as
 584  * nonblocking.
 585  *
 586  * @param host the host name to connect to
 587  * @param port the prot to connect to
 588  * @param error return location for error code
 589  * @returns connection file descriptor or -1 on error
 590  */
 591 int
 592 _dbus_connect_tcp_socket (const char     *host,
 593                           dbus_uint32_t   port,
 594                           DBusError      *error)
 595 {
 596   int fd;
 597   struct sockaddr_in addr;
 598   struct hostent *he;
 599   struct in_addr *haddr;
 600
 601   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 602
 603   fd = socket (AF_INET, SOCK_STREAM, 0);
 604
 605   if (fd < 0)
 606     {
 607       dbus_set_error (error,
 608                       _dbus_error_from_errno (errno),
 609                       "Failed to create socket: %s",
 610                       _dbus_strerror (errno));
 611
 612       return -1;
 613     }
 614
 615   if (host == NULL)
 616     host = "localhost";
 617
 618   he = gethostbyname (host);
 619   if (he == NULL)
 620     {
 621       dbus_set_error (error,
 622                       _dbus_error_from_errno (errno),
 623                       "Failed to lookup hostname: %s",
 624                       host);
 625       close (fd);
 626       return -1;
 627     }
 628
 629   haddr = ((struct in_addr *) (he->h_addr_list)[0]);
 630
 631   _DBUS_ZERO (addr);
 632   memcpy (&addr.sin_addr, haddr, sizeof(struct in_addr));
 633   addr.sin_family = AF_INET;
 634   addr.sin_port = htons (port);
 635
 636   if (connect (fd, (struct sockaddr*) &addr, sizeof (addr)) < 0)
 637     {
 638       dbus_set_error (error,
 639                        _dbus_error_from_errno (errno),
 640                       "Failed to connect to socket %s: %s:%d",
 641                       host, _dbus_strerror (errno), port);
 642
 643       close (fd);
 644       fd = -1;
 645
 646       return -1;
 647     }
 648
 649   if (!_dbus_set_fd_nonblocking (fd, error))
 650     {
 651       close (fd);
 652       fd = -1;
 653
 654       return -1;
 655     }
 656
 657   return fd;
 658 }
 659
 660 /**
 661  * Creates a socket and binds it to the given path,
 662  * then listens on the socket. The socket is
 663  * set to be nonblocking.
 664  *
 665  * @param host the host name to listen on
 666  * @param port the prot to listen on
 667  * @param error return location for errors
 668  * @returns the listening file descriptor or -1 on error
 669  */
 670 int
 671 _dbus_listen_tcp_socket (const char     *host,
 672                          dbus_uint32_t   port,
 673                          DBusError      *error)
 674 {
 675   int listen_fd;
 676   struct sockaddr_in addr;
 677   struct hostent *he;
 678   struct in_addr *haddr;
 679
 680   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 681
 682   listen_fd = socket (AF_INET, SOCK_STREAM, 0);
 683
 684   if (listen_fd < 0)
 685     {
 686       dbus_set_error (error, _dbus_error_from_errno (errno),
 687                       "Failed to create socket \"%s:%d\": %s",
 688                       host, port, _dbus_strerror (errno));
 689       return -1;
 690     }
 691
 692   he = gethostbyname (host);
 693   if (he == NULL)
 694     {
 695       dbus_set_error (error,
 696                       _dbus_error_from_errno (errno),
 697                       "Failed to lookup hostname: %s",
 698                       host);
 699       close (listen_fd);
 700       return -1;
 701     }
 702
 703   haddr = ((struct in_addr *) (he->h_addr_list)[0]);
 704
 705   _DBUS_ZERO (addr);
 706   memcpy (&addr.sin_addr, haddr, sizeof (struct in_addr));
 707   addr.sin_family = AF_INET;
 708   addr.sin_port = htons (port);
 709
 710   if (bind (listen_fd, (struct sockaddr*) &addr, sizeof (struct sockaddr)))
 711     {
 712       dbus_set_error (error, _dbus_error_from_errno (errno),
 713                       "Failed to bind socket \"%s:%d\": %s",
 714                       host, port, _dbus_strerror (errno));
 715       close (listen_fd);
 716       return -1;
 717     }
 718
 719   if (listen (listen_fd, 30 /* backlog */) < 0)
 720     {
 721       dbus_set_error (error, _dbus_error_from_errno (errno),
 722                       "Failed to listen on socket \"%s:%d\": %s",
 723                       host, port, _dbus_strerror (errno));
 724       close (listen_fd);
 725       return -1;
 726     }
 727
 728   if (!_dbus_set_fd_nonblocking (listen_fd, error))
 729     {
 730       close (listen_fd);
 731       return -1;
 732     }
 733
 734   return listen_fd;
 735 }
 736
 737 static dbus_bool_t
 738 write_credentials_byte (int             server_fd,
 739                         DBusError      *error)
 740 {
 741   int bytes_written;
 742   char buf[1] = { '\0' };
 743
 744   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 745
 746  again:
 747
 748   bytes_written = write (server_fd, buf, 1);
 749
 750   if (bytes_written < 0 && errno == EINTR)
 751     goto again;
 752
 753   if (bytes_written < 0)
 754     {
 755       dbus_set_error (error, _dbus_error_from_errno (errno),
 756                       "Failed to write credentials byte: %s",
 757                      _dbus_strerror (errno));
 758       return FALSE;
 759     }
 760   else if (bytes_written == 0)
 761     {
 762       dbus_set_error (error, DBUS_ERROR_IO_ERROR,
 763                       "wrote zero bytes writing credentials byte");
 764       return FALSE;
 765     }
 766   else
 767     {
 768       _dbus_assert (bytes_written == 1);
 769       _dbus_verbose ("wrote credentials byte\n");
 770       return TRUE;
 771     }
 772 }
 773
 774 /**
 775  * Reads a single byte which must be nul (an error occurs otherwise),
 776  * and reads unix credentials if available. Fills in pid/uid/gid with
 777  * -1 if no credentials are available. Return value indicates whether
 778  * a byte was read, not whether we got valid credentials. On some
 779  * systems, such as Linux, reading/writing the byte isn't actually
 780  * required, but we do it anyway just to avoid multiple codepaths.
 781  *
 782  * Fails if no byte is available, so you must select() first.
 783  *
 784  * The point of the byte is that on some systems we have to
 785  * use sendmsg()/recvmsg() to transmit credentials.
 786  *
 787  * @param client_fd the client file descriptor
 788  * @param credentials struct to fill with credentials of client
 789  * @param error location to store error code
 790  * @returns #TRUE on success
 791  */
 792 dbus_bool_t
 793 _dbus_read_credentials_unix_socket  (int              client_fd,
 794                                      DBusCredentials *credentials,
 795                                      DBusError       *error)
 796 {
 797   struct msghdr msg;
 798   struct iovec iov;
 799   char buf;
 800
 801 #ifdef HAVE_CMSGCRED
 802   char cmsgmem[CMSG_SPACE (sizeof (struct cmsgcred))];
 803   struct cmsghdr *cmsg = (struct cmsghdr *) cmsgmem;
 804 #endif
 805
 806   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 807
 808   /* The POSIX spec certainly doesn't promise this, but
 809    * we need these assertions to fail as soon as we're wrong about
 810    * it so we can do the porting fixups
 811    */
 812   _dbus_assert (sizeof (pid_t) <= sizeof (credentials->pid));
 813   _dbus_assert (sizeof (uid_t) <= sizeof (credentials->uid));
 814   _dbus_assert (sizeof (gid_t) <= sizeof (credentials->gid));
 815
 816   _dbus_credentials_clear (credentials);
 817
 818 #if defined(LOCAL_CREDS) && defined(HAVE_CMSGCRED)
 819   /* Set the socket to receive credentials on the next message */
 820   {
 821     int on = 1;
 822     if (setsockopt (client_fd, 0, LOCAL_CREDS, &on, sizeof (on)) < 0)
 823       {
 824         _dbus_verbose ("Unable to set LOCAL_CREDS socket option\n");
 825         return FALSE;
 826       }
 827   }
 828 #endif
 829
 830   iov.iov_base = &buf;
 831   iov.iov_len = 1;
 832
 833   memset (&msg, 0, sizeof (msg));
 834   msg.msg_iov = &iov;
 835   msg.msg_iovlen = 1;
 836
 837 #ifdef HAVE_CMSGCRED
 838   memset (cmsgmem, 0, sizeof (cmsgmem));
 839   msg.msg_control = cmsgmem;
 840   msg.msg_controllen = sizeof (cmsgmem);
 841 #endif
 842
 843  again:
 844   if (recvmsg (client_fd, &msg, 0) < 0)
 845     {
 846       if (errno == EINTR)
 847         goto again;
 848
 849       dbus_set_error (error, _dbus_error_from_errno (errno),
 850                       "Failed to read credentials byte: %s",
 851                       _dbus_strerror (errno));
 852       return FALSE;
 853     }
 854
 855   if (buf != '\0')
 856     {
 857       dbus_set_error (error, DBUS_ERROR_FAILED,
 858                       "Credentials byte was not nul");
 859       return FALSE;
 860     }
 861
 862 #ifdef HAVE_CMSGCRED
 863   if (cmsg->cmsg_len < sizeof (cmsgmem) || cmsg->cmsg_type != SCM_CREDS)
 864     {
 865       dbus_set_error (error, DBUS_ERROR_FAILED);
 866       _dbus_verbose ("Message from recvmsg() was not SCM_CREDS\n");
 867       return FALSE;
 868     }
 869 #endif
 870
 871   _dbus_verbose ("read credentials byte\n");
 872
 873   {
 874 #ifdef SO_PEERCRED
 875     struct ucred cr;
 876     int cr_len = sizeof (cr);
 877
 878     if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
 879         cr_len == sizeof (cr))
 880       {
 881         credentials->pid = cr.pid;
 882         credentials->uid = cr.uid;
 883         credentials->gid = cr.gid;
 884       }
 885     else
 886       {
 887         _dbus_verbose ("Failed to getsockopt() credentials, returned len %d/%d: %s\n",
 888                        cr_len, (int) sizeof (cr), _dbus_strerror (errno));
 889       }
 890 #elif defined(HAVE_CMSGCRED)
 891     struct cmsgcred *cred;
 892
 893     cred = (struct cmsgcred *) CMSG_DATA (cmsg);
 894
 895     credentials->pid = cred->cmcred_pid;
 896     credentials->uid = cred->cmcred_euid;
 897     credentials->gid = cred->cmcred_groups[0];
 898 #else /* !SO_PEERCRED && !HAVE_CMSGCRED */
 899     _dbus_verbose ("Socket credentials not supported on this OS\n");
 900 #endif
 901   }
 902
 903   _dbus_verbose ("Credentials:"
 904                  "  pid "DBUS_PID_FORMAT
 905                  "  uid "DBUS_UID_FORMAT
 906                  "  gid "DBUS_GID_FORMAT"\n",
 907                  credentials->pid,
 908                  credentials->uid,
 909                  credentials->gid);
 910
 911   return TRUE;
 912 }
 913
 914 /**
 915  * Sends a single nul byte with our UNIX credentials as ancillary
 916  * data.  Returns #TRUE if the data was successfully written.  On
 917  * systems that don't support sending credentials, just writes a byte,
 918  * doesn't send any credentials.  On some systems, such as Linux,
 919  * reading/writing the byte isn't actually required, but we do it
 920  * anyway just to avoid multiple codepaths.
 921  *
 922  * Fails if no byte can be written, so you must select() first.
 923  *
 924  * The point of the byte is that on some systems we have to
 925  * use sendmsg()/recvmsg() to transmit credentials.
 926  *
 927  * @param server_fd file descriptor for connection to server
 928  * @param error return location for error code
 929  * @returns #TRUE if the byte was sent
 930  */
 931 dbus_bool_t
 932 _dbus_send_credentials_unix_socket  (int              server_fd,
 933                                      DBusError       *error)
 934 {
 935   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
 936
 937   if (write_credentials_byte (server_fd, error))
 938     return TRUE;
 939   else
 940     return FALSE;
 941 }
 942
 943 /**
 944  * Accepts a connection on a listening socket.
 945  * Handles EINTR for you.
 946  *
 947  * @param listen_fd the listen file descriptor
 948  * @returns the connection fd of the client, or -1 on error
 949  */
 950 int
 951 _dbus_accept  (int listen_fd)
 952 {
 953   int client_fd;
 954   struct sockaddr addr;
 955   socklen_t addrlen;
 956
 957   addrlen = sizeof (addr);
 958
 959  retry:
 960   client_fd = accept (listen_fd, &addr, &addrlen);
 961
 962   if (client_fd < 0)
 963     {
 964       if (errno == EINTR)
 965         goto retry;
 966     }
 967
 968   return client_fd;
 969 }
 970
 971 /** @} */
 972
 973 /**
 974  * @addtogroup DBusString
 975  *
 976  * @{
 977  */
 978 /**
 979  * Appends an integer to a DBusString.
 980  *
 981  * @param str the string
 982  * @param value the integer value
 983  * @returns #FALSE if not enough memory or other failure.
 984  */
 985 dbus_bool_t
 986 _dbus_string_append_int (DBusString *str,
 987                          long        value)
 988 {
 989   /* this calculation is from comp.lang.c faq */
 990 #define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1)  /* +1 for '-' */
 991   int orig_len;
 992   int i;
 993   char *buf;
 994
 995   orig_len = _dbus_string_get_length (str);
 996
 997   if (!_dbus_string_lengthen (str, MAX_LONG_LEN))
 998     return FALSE;
 999
1000   buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);
1001
1002   snprintf (buf, MAX_LONG_LEN, "%ld", value);
1003
1004   i = 0;
1005   while (*buf)
1006     {
1007       ++buf;
1008       ++i;
1009     }
1010
1011   _dbus_string_shorten (str, MAX_LONG_LEN - i);
1012
1013   return TRUE;
1014 }
1015
1016 /**
1017  * Appends an unsigned integer to a DBusString.
1018  *
1019  * @param str the string
1020  * @param value the integer value
1021  * @returns #FALSE if not enough memory or other failure.
1022  */
1023 dbus_bool_t
1024 _dbus_string_append_uint (DBusString    *str,
1025                           unsigned long  value)
1026 {
1027   /* this is wrong, but definitely on the high side. */
1028 #define MAX_ULONG_LEN (MAX_LONG_LEN * 2)
1029   int orig_len;
1030   int i;
1031   char *buf;
1032
1033   orig_len = _dbus_string_get_length (str);
1034
1035   if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))
1036     return FALSE;
1037
1038   buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);
1039
1040   snprintf (buf, MAX_ULONG_LEN, "%lu", value);
1041
1042   i = 0;
1043   while (*buf)
1044     {
1045       ++buf;
1046       ++i;
1047     }
1048
1049   _dbus_string_shorten (str, MAX_ULONG_LEN - i);
1050
1051   return TRUE;
1052 }
1053
1054 /**
1055  * Appends a double to a DBusString.
1056  *
1057  * @param str the string
1058  * @param value the floating point value
1059  * @returns #FALSE if not enough memory or other failure.
1060  */
1061 dbus_bool_t
1062 _dbus_string_append_double (DBusString *str,
1063                             double      value)
1064 {
1065 #define MAX_DOUBLE_LEN 64 /* this is completely made up :-/ */
1066   int orig_len;
1067   char *buf;
1068   int i;
1069
1070   orig_len = _dbus_string_get_length (str);
1071
1072   if (!_dbus_string_lengthen (str, MAX_DOUBLE_LEN))
1073     return FALSE;
1074
1075   buf = _dbus_string_get_data_len (str, orig_len, MAX_DOUBLE_LEN);
1076
1077   snprintf (buf, MAX_LONG_LEN, "%g", value);
1078
1079   i = 0;
1080   while (*buf)
1081     {
1082       ++buf;
1083       ++i;
1084     }
1085
1086   _dbus_string_shorten (str, MAX_DOUBLE_LEN - i);
1087
1088   return TRUE;
1089 }
1090
1091 /**
1092  * Parses an integer contained in a DBusString. Either return parameter
1093  * may be #NULL if you aren't interested in it. The integer is parsed
1094  * and stored in value_return. Return parameters are not initialized
1095  * if the function returns #FALSE.
1096  *
1097  * @param str the string
1098  * @param start the byte index of the start of the integer
1099  * @param value_return return location of the integer value or #NULL
1100  * @param end_return return location of the end of the integer, or #NULL
1101  * @returns #TRUE on success
1102  */
1103 dbus_bool_t
1104 _dbus_string_parse_int (const DBusString *str,
1105                         int               start,
1106                         long             *value_return,
1107                         int              *end_return)
1108 {
1109   long v;
1110   const char *p;
1111   char *end;
1112
1113   p = _dbus_string_get_const_data_len (str, start,
1114                                        _dbus_string_get_length (str) - start);
1115
1116   end = NULL;
1117   errno = 0;
1118   v = strtol (p, &end, 0);
1119   if (end == NULL || end == p || errno != 0)
1120     return FALSE;
1121
1122   if (value_return)
1123     *value_return = v;
1124   if (end_return)
1125     *end_return = start + (end - p);
1126
1127   return TRUE;
1128 }
1129
1130 #ifdef DBUS_BUILD_TESTS
1131 /* Not currently used, so only built when tests are enabled */
1132 /**
1133  * Parses an unsigned integer contained in a DBusString. Either return
1134  * parameter may be #NULL if you aren't interested in it. The integer
1135  * is parsed and stored in value_return. Return parameters are not
1136  * initialized if the function returns #FALSE.
1137  *
1138  * @param str the string
1139  * @param start the byte index of the start of the integer
1140  * @param value_return return location of the integer value or #NULL
1141  * @param end_return return location of the end of the integer, or #NULL
1142  * @returns #TRUE on success
1143  */
1144 dbus_bool_t
1145 _dbus_string_parse_uint (const DBusString *str,
1146                          int               start,
1147                          unsigned long    *value_return,
1148                          int              *end_return)
1149 {
1150   unsigned long v;
1151   const char *p;
1152   char *end;
1153
1154   p = _dbus_string_get_const_data_len (str, start,
1155                                        _dbus_string_get_length (str) - start);
1156
1157   end = NULL;
1158   errno = 0;
1159   v = strtoul (p, &end, 0);
1160   if (end == NULL || end == p || errno != 0)
1161     return FALSE;
1162
1163   if (value_return)
1164     *value_return = v;
1165   if (end_return)
1166     *end_return = start + (end - p);
1167
1168   return TRUE;
1169 }
1170 #endif /* DBUS_BUILD_TESTS */
1171
1172 static dbus_bool_t
1173 ascii_isspace (char c)
1174 {
1175   return (c == ' ' ||
1176           c == '\f' ||
1177           c == '\n' ||
1178           c == '\r' ||
1179           c == '\t' ||
1180           c == '\v');
1181 }
1182
1183 static dbus_bool_t
1184 ascii_isdigit (char c)
1185 {
1186   return c >= '0' && c <= '9';
1187 }
1188
1189 static dbus_bool_t
1190 ascii_isxdigit (char c)
1191 {
1192   return (ascii_isdigit (c) ||
1193           (c >= 'a' && c <= 'f') ||
1194           (c >= 'A' && c <= 'F'));
1195 }
1196
1197
1198 /* Calls strtod in a locale-independent fashion, by looking at
1199  * the locale data and patching the decimal comma to a point.
1200  *
1201  * Relicensed from glib.
1202  */
1203 static double
1204 ascii_strtod (const char *nptr,
1205               char      **endptr)
1206 {
1207   char *fail_pos;
1208   double val;
1209   struct lconv *locale_data;
1210   const char *decimal_point;
1211   int decimal_point_len;
1212   const char *p, *decimal_point_pos;
1213   const char *end = NULL; /* Silence gcc */
1214
1215   fail_pos = NULL;
1216
1217   locale_data = localeconv ();
1218   decimal_point = locale_data->decimal_point;
1219   decimal_point_len = strlen (decimal_point);
1220
1221   _dbus_assert (decimal_point_len != 0);
1222
1223   decimal_point_pos = NULL;
1224   if (decimal_point[0] != '.' ||
1225       decimal_point[1] != 0)
1226     {
1227       p = nptr;
1228       /* Skip leading space */
1229       while (ascii_isspace (*p))
1230         p++;
1231
1232       /* Skip leading optional sign */
1233       if (*p == '+' || *p == '-')
1234         p++;
1235
1236       if (p[0] == '0' &&
1237           (p[1] == 'x' || p[1] == 'X'))
1238         {
1239           p += 2;
1240           /* HEX - find the (optional) decimal point */
1241
1242           while (ascii_isxdigit (*p))
1243             p++;
1244
1245           if (*p == '.')
1246             {
1247               decimal_point_pos = p++;
1248
1249               while (ascii_isxdigit (*p))
1250                 p++;
1251
1252               if (*p == 'p' || *p == 'P')
1253                 p++;
1254               if (*p == '+' || *p == '-')
1255                 p++;
1256               while (ascii_isdigit (*p))
1257                 p++;
1258               end = p;
1259             }
1260         }
1261       else
1262         {
1263           while (ascii_isdigit (*p))
1264             p++;
1265
1266           if (*p == '.')
1267             {
1268               decimal_point_pos = p++;
1269
1270               while (ascii_isdigit (*p))
1271                 p++;
1272
1273               if (*p == 'e' || *p == 'E')
1274                 p++;
1275               if (*p == '+' || *p == '-')
1276                 p++;
1277               while (ascii_isdigit (*p))
1278                 p++;
1279               end = p;
1280             }
1281         }
1282       /* For the other cases, we need not convert the decimal point */
1283     }
1284
1285   /* Set errno to zero, so that we can distinguish zero results
1286      and underflows */
1287   errno = 0;
1288
1289   if (decimal_point_pos)
1290     {
1291       char *copy, *c;
1292
1293       /* We need to convert the '.' to the locale specific decimal point */
1294       copy = dbus_malloc (end - nptr + 1 + decimal_point_len);
1295
1296       c = copy;
1297       memcpy (c, nptr, decimal_point_pos - nptr);
1298       c += decimal_point_pos - nptr;
1299       memcpy (c, decimal_point, decimal_point_len);
1300       c += decimal_point_len;
1301       memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1));
1302       c += end - (decimal_point_pos + 1);
1303       *c = 0;
1304
1305       val = strtod (copy, &fail_pos);
1306
1307       if (fail_pos)
1308         {
1309           if (fail_pos > decimal_point_pos)
1310             fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
1311           else
1312             fail_pos = (char *)nptr + (fail_pos - copy);
1313         }
1314
1315       dbus_free (copy);
1316
1317     }
1318   else
1319     val = strtod (nptr, &fail_pos);
1320
1321   if (endptr)
1322     *endptr = fail_pos;
1323
1324   return val;
1325 }
1326
1327
1328 /**
1329  * Parses a floating point number contained in a DBusString. Either
1330  * return parameter may be #NULL if you aren't interested in it. The
1331  * integer is parsed and stored in value_return. Return parameters are
1332  * not initialized if the function returns #FALSE.
1333  *
1334  * @param str the string
1335  * @param start the byte index of the start of the float
1336  * @param value_return return location of the float value or #NULL
1337  * @param end_return return location of the end of the float, or #NULL
1338  * @returns #TRUE on success
1339  */
1340 dbus_bool_t
1341 _dbus_string_parse_double (const DBusString *str,
1342                            int               start,
1343                            double           *value_return,
1344                            int              *end_return)
1345 {
1346   double v;
1347   const char *p;
1348   char *end;
1349
1350   p = _dbus_string_get_const_data_len (str, start,
1351                                        _dbus_string_get_length (str) - start);
1352
1353   end = NULL;
1354   errno = 0;
1355   v = ascii_strtod (p, &end);
1356   if (end == NULL || end == p || errno != 0)
1357     return FALSE;
1358
1359   if (value_return)
1360     *value_return = v;
1361   if (end_return)
1362     *end_return = start + (end - p);
1363
1364   return TRUE;
1365 }
1366
1367 /** @} */ /* DBusString group */
1368
1369 /**
1370  * @addtogroup DBusInternalsUtils
1371  * @{
1372  */
1373 static dbus_bool_t
1374 fill_user_info_from_passwd (struct passwd *p,
1375                             DBusUserInfo  *info,
1376                             DBusError     *error)
1377 {
1378   _dbus_assert (p->pw_name != NULL);
1379   _dbus_assert (p->pw_dir != NULL);
1380
1381   info->uid = p->pw_uid;
1382   info->primary_gid = p->pw_gid;
1383   info->username = _dbus_strdup (p->pw_name);
1384   info->homedir = _dbus_strdup (p->pw_dir);
1385
1386   if (info->username == NULL ||
1387       info->homedir == NULL)
1388     {
1389       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1390       return FALSE;
1391     }
1392
1393   return TRUE;
1394 }
1395
1396 static dbus_bool_t
1397 fill_user_info (DBusUserInfo       *info,
1398                 dbus_uid_t          uid,
1399                 const DBusString   *username,
1400                 DBusError          *error)
1401 {
1402   const char *username_c;
1403
1404   /* exactly one of username/uid provided */
1405   _dbus_assert (username != NULL || uid != DBUS_UID_UNSET);
1406   _dbus_assert (username == NULL || uid == DBUS_UID_UNSET);
1407
1408   info->uid = DBUS_UID_UNSET;
1409   info->primary_gid = DBUS_GID_UNSET;
1410   info->group_ids = NULL;
1411   info->n_group_ids = 0;
1412   info->username = NULL;
1413   info->homedir = NULL;
1414
1415   if (username != NULL)
1416     username_c = _dbus_string_get_const_data (username);
1417   else
1418     username_c = NULL;
1419
1420   /* For now assuming that the getpwnam() and getpwuid() flavors
1421    * are always symmetrical, if not we have to add more configure
1422    * checks
1423    */
1424
1425 #if defined (HAVE_POSIX_GETPWNAME_R) || defined (HAVE_NONPOSIX_GETPWNAME_R)
1426   {
1427     struct passwd *p;
1428     int result;
1429     char buf[1024];
1430     struct passwd p_str;
1431
1432     p = NULL;
1433 #ifdef HAVE_POSIX_GETPWNAME_R
1434     if (uid >= 0)
1435       result = getpwuid_r (uid, &p_str, buf, sizeof (buf),
1436                            &p);
1437     else
1438       result = getpwnam_r (username_c, &p_str, buf, sizeof (buf),
1439                            &p);
1440 #else
1441     if (uid != DBUS_UID_UNSET)
1442       p = getpwuid_r (uid, &p_str, buf, sizeof (buf));
1443     else
1444       p = getpwnam_r (username_c, &p_str, buf, sizeof (buf));
1445     result = 0;
1446 #endif /* !HAVE_POSIX_GETPWNAME_R */
1447     if (result == 0 && p == &p_str)
1448       {
1449         if (!fill_user_info_from_passwd (p, info, error))
1450           return FALSE;
1451       }
1452     else
1453       {
1454         dbus_set_error (error, _dbus_error_from_errno (errno),
1455                         "User \"%s\" unknown or no memory to allocate password entry\n",
1456                         username_c ? username_c : "???");
1457         _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
1458         return FALSE;
1459       }
1460   }
1461 #else /* ! HAVE_GETPWNAM_R */
1462   {
1463     /* I guess we're screwed on thread safety here */
1464     struct passwd *p;
1465
1466     if (uid != DBUS_UID_UNSET)
1467       p = getpwuid (uid);
1468     else
1469       p = getpwnam (username_c);
1470
1471     if (p != NULL)
1472       {
1473         if (!fill_user_info_from_passwd (p, info, error))
1474           return FALSE;
1475       }
1476     else
1477       {
1478         dbus_set_error (error, _dbus_error_from_errno (errno),
1479                         "User \"%s\" unknown or no memory to allocate password entry\n",
1480                         username_c ? username_c : "???");
1481         _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
1482         return FALSE;
1483       }
1484   }
1485 #endif  /* ! HAVE_GETPWNAM_R */
1486
1487   /* Fill this in so we can use it to get groups */
1488   username_c = info->username;
1489
1490 #ifdef HAVE_GETGROUPLIST
1491   {
1492     gid_t *buf;
1493     int buf_count;
1494     int i;
1495
1496     buf_count = 17;
1497     buf = dbus_new (gid_t, buf_count);
1498     if (buf == NULL)
1499       {
1500         dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1501         goto failed;
1502       }
1503
1504     if (getgrouplist (username_c,
1505                       info->primary_gid,
1506                       buf, &buf_count) < 0)
1507       {
1508         gid_t *new = dbus_realloc (buf, buf_count * sizeof (buf[0]));
1509         if (new == NULL)
1510           {
1511             dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1512             dbus_free (buf);
1513             goto failed;
1514           }
1515
1516         buf = new;
1517
1518         errno = 0;
1519         if (getgrouplist (username_c, info->primary_gid, buf, &buf_count) < 0)
1520           {
1521             dbus_set_error (error,
1522                             _dbus_error_from_errno (errno),
1523                             "Failed to get groups for username \"%s\" primary GID "
1524                             DBUS_GID_FORMAT ": %s\n",
1525                             username_c, info->primary_gid,
1526                             _dbus_strerror (errno));
1527             dbus_free (buf);
1528             goto failed;
1529           }
1530       }
1531
1532     info->group_ids = dbus_new (dbus_gid_t, buf_count);
1533     if (info->group_ids == NULL)
1534       {
1535         dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1536         dbus_free (buf);
1537         goto failed;
1538       }
1539
1540     for (i = 0; i < buf_count; ++i)
1541       info->group_ids[i] = buf[i];
1542
1543     info->n_group_ids = buf_count;
1544
1545     dbus_free (buf);
1546   }
1547 #else  /* HAVE_GETGROUPLIST */
1548   {
1549     /* We just get the one group ID */
1550     info->group_ids = dbus_new (dbus_gid_t, 1);
1551     if (info->group_ids == NULL)
1552       {
1553         dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1554         goto failed;
1555       }
1556
1557     info->n_group_ids = 1;
1558
1559     (info->group_ids)[0] = info->primary_gid;
1560   }
1561 #endif /* HAVE_GETGROUPLIST */
1562
1563   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
1564
1565   return TRUE;
1566
1567  failed:
1568   _DBUS_ASSERT_ERROR_IS_SET (error);
1569   _dbus_user_info_free (info);
1570   return FALSE;
1571 }
1572
1573 /**
1574  * Gets user info for the given username.
1575  *
1576  * @param info user info object to initialize
1577  * @param username the username
1578  * @param error error return
1579  * @returns #TRUE on success
1580  */
1581 dbus_bool_t
1582 _dbus_user_info_fill (DBusUserInfo     *info,
1583                       const DBusString *username,
1584                       DBusError        *error)
1585 {
1586   return fill_user_info (info, DBUS_UID_UNSET,
1587                          username, error);
1588 }
1589
1590 /**
1591  * Gets user info for the given user ID.
1592  *
1593  * @param info user info object to initialize
1594  * @param uid the user ID
1595  * @param error error return
1596  * @returns #TRUE on success
1597  */
1598 dbus_bool_t
1599 _dbus_user_info_fill_uid (DBusUserInfo *info,
1600                           dbus_uid_t    uid,
1601                           DBusError    *error)
1602 {
1603   return fill_user_info (info, uid,
1604                          NULL, error);
1605 }
1606
1607 /**
1608  * Frees the members of info
1609  * (but not info itself)
1610  * @param info the user info struct
1611  */
1612 void
1613 _dbus_user_info_free (DBusUserInfo *info)
1614 {
1615   dbus_free (info->group_ids);
1616   dbus_free (info->username);
1617   dbus_free (info->homedir);
1618 }
1619
1620 static dbus_bool_t
1621 fill_user_info_from_group (struct group  *g,
1622                            DBusGroupInfo *info,
1623                            DBusError     *error)
1624 {
1625   _dbus_assert (g->gr_name != NULL);
1626
1627   info->gid = g->gr_gid;
1628   info->groupname = _dbus_strdup (g->gr_name);
1629
1630   /* info->members = dbus_strdupv (g->gr_mem) */
1631
1632   if (info->groupname == NULL)
1633     {
1634       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
1635       return FALSE;
1636     }
1637
1638   return TRUE;
1639 }
1640
1641 static dbus_bool_t
1642 fill_group_info (DBusGroupInfo    *info,
1643                  dbus_gid_t        gid,
1644                  const DBusString *groupname,
1645                  DBusError        *error)
1646 {
1647   const char *group_c_str;
1648
1649   _dbus_assert (groupname != NULL || gid != DBUS_GID_UNSET);
1650   _dbus_assert (groupname == NULL || gid == DBUS_GID_UNSET);
1651
1652   if (groupname)
1653     group_c_str = _dbus_string_get_const_data (groupname);
1654   else
1655     group_c_str = NULL;
1656
1657   /* For now assuming that the getgrnam() and getgrgid() flavors
1658    * always correspond to the pwnam flavors, if not we have
1659    * to add more configure checks.
1660    */
1661
1662 #if defined (HAVE_POSIX_GETPWNAME_R) || defined (HAVE_NONPOSIX_GETPWNAME_R)
1663   {
1664     struct group *g;
1665     int result;
1666     char buf[1024];
1667     struct group g_str;
1668
1669     g = NULL;
1670 #ifdef HAVE_POSIX_GETPWNAME_R
1671
1672     if (group_c_str)
1673       result = getgrnam_r (group_c_str, &g_str, buf, sizeof (buf),
1674                            &g);
1675     else
1676       result = getgrgid_r (gid, &g_str, buf, sizeof (buf),
1677                            &g);
1678 #else
1679     p = getgrnam_r (group_c_str, &g_str, buf, sizeof (buf));
1680     result = 0;
1681 #endif /* !HAVE_POSIX_GETPWNAME_R */
1682     if (result == 0 && g == &g_str)
1683       {
1684         return fill_user_info_from_group (g, info, error);
1685       }
1686     else
1687       {
1688         dbus_set_error (error, _dbus_error_from_errno (errno),
1689                         "Group %s unknown or failed to look it up\n",
1690                         group_c_str ? group_c_str : "???");
1691         return FALSE;
1692       }
1693   }
1694 #else /* ! HAVE_GETPWNAM_R */
1695   {
1696     /* I guess we're screwed on thread safety here */
1697     struct group *g;
1698
1699     g = getgrnam (group_c_str);
1700
1701     if (g != NULL)
1702       {
1703         return fill_user_info_from_group (g, info, error);
1704       }
1705     else
1706       {
1707         dbus_set_error (error, _dbus_error_from_errno (errno),
1708                         "Group %s unknown or failed to look it up\n",
1709                         group_c_str ? group_c_str : "???");
1710         return FALSE;
1711       }
1712   }
1713 #endif  /* ! HAVE_GETPWNAM_R */
1714 }
1715
1716 /**
1717  * Initializes the given DBusGroupInfo struct
1718  * with information about the given group name.
1719  *
1720  * @param info the group info struct
1721  * @param groupname name of group
1722  * @param error the error return
1723  * @returns #FALSE if error is set
1724  */
1725 dbus_bool_t
1726 _dbus_group_info_fill (DBusGroupInfo    *info,
1727                        const DBusString *groupname,
1728                        DBusError        *error)
1729 {
1730   return fill_group_info (info, DBUS_GID_UNSET,
1731                           groupname, error);
1732
1733 }
1734
1735 /**
1736  * Initializes the given DBusGroupInfo struct
1737  * with information about the given group ID.
1738  *
1739  * @param info the group info struct
1740  * @param gid group ID
1741  * @param error the error return
1742  * @returns #FALSE if error is set
1743  */
1744 dbus_bool_t
1745 _dbus_group_info_fill_gid (DBusGroupInfo *info,
1746                            dbus_gid_t     gid,
1747                            DBusError     *error)
1748 {
1749   return fill_group_info (info, gid, NULL, error);
1750 }
1751
1752 /**
1753  * Frees the members of info (but not info itself).
1754  *
1755  * @param info the group info
1756  */
1757 void
1758 _dbus_group_info_free (DBusGroupInfo    *info)
1759 {
1760   dbus_free (info->groupname);
1761 }
1762
1763 /**
1764  * Sets fields in DBusCredentials to DBUS_PID_UNSET,
1765  * DBUS_UID_UNSET, DBUS_GID_UNSET.
1766  *
1767  * @param credentials the credentials object to fill in
1768  */
1769 void
1770 _dbus_credentials_clear (DBusCredentials *credentials)
1771 {
1772   credentials->pid = DBUS_PID_UNSET;
1773   credentials->uid = DBUS_UID_UNSET;
1774   credentials->gid = DBUS_GID_UNSET;
1775 }
1776
1777 /**
1778  * Gets the credentials of the current process.
1779  *
1780  * @param credentials credentials to fill in.
1781  */
1782 void
1783 _dbus_credentials_from_current_process (DBusCredentials *credentials)
1784 {
1785   /* The POSIX spec certainly doesn't promise this, but
1786    * we need these assertions to fail as soon as we're wrong about
1787    * it so we can do the porting fixups
1788    */
1789   _dbus_assert (sizeof (pid_t) <= sizeof (credentials->pid));
1790   _dbus_assert (sizeof (uid_t) <= sizeof (credentials->uid));
1791   _dbus_assert (sizeof (gid_t) <= sizeof (credentials->gid));
1792
1793   credentials->pid = getpid ();
1794   credentials->uid = getuid ();
1795   credentials->gid = getgid ();
1796 }
1797
1798 /**
1799  * Checks whether the provided_credentials are allowed to log in
1800  * as the expected_credentials.
1801  *
1802  * @param expected_credentials credentials we're trying to log in as
1803  * @param provided_credentials credentials we have
1804  * @returns #TRUE if we can log in
1805  */
1806 dbus_bool_t
1807 _dbus_credentials_match (const DBusCredentials *expected_credentials,
1808                          const DBusCredentials *provided_credentials)
1809 {
1810   if (provided_credentials->uid == DBUS_UID_UNSET)
1811     return FALSE;
1812   else if (expected_credentials->uid == DBUS_UID_UNSET)
1813     return FALSE;
1814   else if (provided_credentials->uid == 0)
1815     return TRUE;
1816   else if (provided_credentials->uid == expected_credentials->uid)
1817     return TRUE;
1818   else
1819     return FALSE;
1820 }
1821
1822 /**
1823  * Gets our process ID
1824  * @returns process ID
1825  */
1826 unsigned long
1827 _dbus_getpid (void)
1828 {
1829   return getpid ();
1830 }
1831
1832 /** Gets our UID
1833  * @returns process UID
1834  */
1835 dbus_uid_t
1836 _dbus_getuid (void)
1837 {
1838   return getuid ();
1839 }
1840
1841 /** Gets our GID
1842  * @returns process GID
1843  */
1844 dbus_gid_t
1845 _dbus_getgid (void)
1846 {
1847   return getgid ();
1848 }
1849
1850 _DBUS_DEFINE_GLOBAL_LOCK (atomic);
1851
1852 #ifdef DBUS_USE_ATOMIC_INT_486
1853 /* Taken from CVS version 1.7 of glibc's sysdeps/i386/i486/atomicity.h */
1854 /* Since the asm stuff here is gcc-specific we go ahead and use "inline" also */
1855 static inline dbus_int32_t
1856 atomic_exchange_and_add (DBusAtomic            *atomic,
1857                          volatile dbus_int32_t  val)
1858 {
1859   register dbus_int32_t result;
1860
1861   __asm__ __volatile__ ("lock; xaddl %0,%1"
1862                         : "=r" (result), "=m" (atomic->value)
1863                         : "0" (val), "m" (atomic->value));
1864   return result;
1865 }
1866 #endif
1867
1868 /**
1869  * Atomically increments an integer
1870  *
1871  * @param atomic pointer to the integer to increment
1872  * @returns the value before incrementing
1873  *
1874  * @todo implement arch-specific faster atomic ops
1875  */
1876 dbus_int32_t
1877 _dbus_atomic_inc (DBusAtomic *atomic)
1878 {
1879 #ifdef DBUS_USE_ATOMIC_INT_486
1880   return atomic_exchange_and_add (atomic, 1);
1881 #else
1882   dbus_int32_t res;
1883   _DBUS_LOCK (atomic);
1884   res = atomic->value;
1885   atomic->value += 1;
1886   _DBUS_UNLOCK (atomic);
1887   return res;
1888 #endif
1889 }
1890
1891 /**
1892  * Atomically decrement an integer
1893  *
1894  * @param atomic pointer to the integer to decrement
1895  * @returns the value before decrementing
1896  *
1897  * @todo implement arch-specific faster atomic ops
1898  */
1899 dbus_int32_t
1900 _dbus_atomic_dec (DBusAtomic *atomic)
1901 {
1902 #ifdef DBUS_USE_ATOMIC_INT_486
1903   return atomic_exchange_and_add (atomic, -1);
1904 #else
1905   dbus_int32_t res;
1906
1907   _DBUS_LOCK (atomic);
1908   res = atomic->value;
1909   atomic->value -= 1;
1910   _DBUS_UNLOCK (atomic);
1911   return res;
1912 #endif
1913 }
1914
1915 /**
1916  * Wrapper for poll().
1917  *
1918  * @param fds the file descriptors to poll
1919  * @param n_fds number of descriptors in the array
1920  * @param timeout_milliseconds timeout or -1 for infinite
1921  * @returns numbers of fds with revents, or <0 on error
1922  */
1923 int
1924 _dbus_poll (DBusPollFD *fds,
1925             int         n_fds,
1926             int         timeout_milliseconds)
1927 {
1928 #ifdef HAVE_POLL
1929   /* This big thing is a constant expression and should get optimized
1930    * out of existence. So it's more robust than a configure check at
1931    * no cost.
1932    */
1933   if (_DBUS_POLLIN == POLLIN &&
1934       _DBUS_POLLPRI == POLLPRI &&
1935       _DBUS_POLLOUT == POLLOUT &&
1936       _DBUS_POLLERR == POLLERR &&
1937       _DBUS_POLLHUP == POLLHUP &&
1938       _DBUS_POLLNVAL == POLLNVAL &&
1939       sizeof (DBusPollFD) == sizeof (struct pollfd) &&
1940       _DBUS_STRUCT_OFFSET (DBusPollFD, fd) ==
1941       _DBUS_STRUCT_OFFSET (struct pollfd, fd) &&
1942       _DBUS_STRUCT_OFFSET (DBusPollFD, events) ==
1943       _DBUS_STRUCT_OFFSET (struct pollfd, events) &&
1944       _DBUS_STRUCT_OFFSET (DBusPollFD, revents) ==
1945       _DBUS_STRUCT_OFFSET (struct pollfd, revents))
1946     {
1947       return poll ((struct pollfd*) fds,
1948                    n_fds,
1949                    timeout_milliseconds);
1950     }
1951   else
1952     {
1953       /* We have to convert the DBusPollFD to an array of
1954        * struct pollfd, poll, and convert back.
1955        */
1956       _dbus_warn ("didn't implement poll() properly for this system yet\n");
1957       return -1;
1958     }
1959 #else /* ! HAVE_POLL */
1960
1961   fd_set read_set, write_set, err_set;
1962   int max_fd = 0;
1963   int i;
1964   struct timeval tv;
1965   int ready;
1966
1967   FD_ZERO (&read_set);
1968   FD_ZERO (&write_set);
1969   FD_ZERO (&err_set);
1970
1971   for (i = 0; i < n_fds; i++)
1972     {
1973       DBusPollFD f = fds[i];
1974
1975       if (f.events & _DBUS_POLLIN)
1976         FD_SET (f.fd, &read_set);
1977
1978       if (f.events & _DBUS_POLLOUT)
1979         FD_SET (f.fd, &write_set);
1980
1981       FD_SET (f.fd, &err_set);
1982
1983       max_fd = MAX (max_fd, f.fd);
1984     }
1985
1986   tv.tv_sec = timeout_milliseconds / 1000;
1987   tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
1988
1989   ready = select (max_fd + 1, &read_set, &write_set, &err_set, &tv);
1990
1991   if (ready > 0)
1992     {
1993       for (i = 0; i < n_fds; i++)
1994         {
1995           DBusPollFD f = fds[i];
1996
1997           f.revents = 0;
1998
1999           if (FD_ISSET (f.fd, &read_set))
2000             f.revents |= _DBUS_POLLIN;
2001
2002           if (FD_ISSET (f.fd, &write_set))
2003             f.revents |= _DBUS_POLLOUT;
2004
2005           if (FD_ISSET (f.fd, &err_set))
2006             f.revents |= _DBUS_POLLERR;
2007         }
2008     }
2009
2010   return ready;
2011 #endif
2012 }
2013
2014 /** nanoseconds in a second */
2015 #define NANOSECONDS_PER_SECOND       1000000000
2016 /** microseconds in a second */
2017 #define MICROSECONDS_PER_SECOND      1000000
2018 /** milliseconds in a second */
2019 #define MILLISECONDS_PER_SECOND      1000
2020 /** nanoseconds in a millisecond */
2021 #define NANOSECONDS_PER_MILLISECOND  1000000
2022 /** microseconds in a millisecond */
2023 #define MICROSECONDS_PER_MILLISECOND 1000
2024
2025 /**
2026  * Sleeps the given number of milliseconds.
2027  * @param milliseconds number of milliseconds
2028  */
2029 void
2030 _dbus_sleep_milliseconds (int milliseconds)
2031 {
2032 #ifdef HAVE_NANOSLEEP
2033   struct timespec req;
2034   struct timespec rem;
2035
2036   req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
2037   req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
2038   rem.tv_sec = 0;
2039   rem.tv_nsec = 0;
2040
2041   while (nanosleep (&req, &rem) < 0 && errno == EINTR)
2042     req = rem;
2043 #elif defined (HAVE_USLEEP)
2044   usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
2045 #else /* ! HAVE_USLEEP */
2046   sleep (MAX (milliseconds / 1000, 1));
2047 #endif
2048 }
2049
2050 /**
2051  * Get current time, as in gettimeofday().
2052  *
2053  * @param tv_sec return location for number of seconds
2054  * @param tv_usec return location for number of microseconds (thousandths)
2055  */
2056 void
2057 _dbus_get_current_time (long *tv_sec,
2058                         long *tv_usec)
2059 {
2060   struct timeval t;
2061
2062   gettimeofday (&t, NULL);
2063
2064   if (tv_sec)
2065     *tv_sec = t.tv_sec;
2066   if (tv_usec)
2067     *tv_usec = t.tv_usec;
2068 }
2069
2070 /**
2071  * Appends the contents of the given file to the string,
2072  * returning error code. At the moment, won't open a file
2073  * more than a megabyte in size.
2074  *
2075  * @param str the string to append to
2076  * @param filename filename to load
2077  * @param error place to set an error
2078  * @returns #FALSE if error was set
2079  */
2080 dbus_bool_t
2081 _dbus_file_get_contents (DBusString       *str,
2082                          const DBusString *filename,
2083                          DBusError        *error)
2084 {
2085   int fd;
2086   struct stat sb;
2087   int orig_len;
2088   int total;
2089   const char *filename_c;
2090
2091   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2092
2093   filename_c = _dbus_string_get_const_data (filename);
2094
2095   /* O_BINARY useful on Cygwin */
2096   fd = open (filename_c, O_RDONLY | O_BINARY);
2097   if (fd < 0)
2098     {
2099       dbus_set_error (error, _dbus_error_from_errno (errno),
2100                       "Failed to open \"%s\": %s",
2101                       filename_c,
2102                       _dbus_strerror (errno));
2103       return FALSE;
2104     }
2105
2106   if (fstat (fd, &sb) < 0)
2107     {
2108       dbus_set_error (error, _dbus_error_from_errno (errno),
2109                       "Failed to stat \"%s\": %s",
2110                       filename_c,
2111                       _dbus_strerror (errno));
2112
2113       _dbus_verbose ("fstat() failed: %s",
2114                      _dbus_strerror (errno));
2115
2116       close (fd);
2117
2118       return FALSE;
2119     }
2120
2121   if (sb.st_size > _DBUS_ONE_MEGABYTE)
2122     {
2123       dbus_set_error (error, DBUS_ERROR_FAILED,
2124                       "File size %lu of \"%s\" is too large.",
2125                       filename_c, (unsigned long) sb.st_size);
2126       close (fd);
2127       return FALSE;
2128     }
2129
2130   total = 0;
2131   orig_len = _dbus_string_get_length (str);
2132   if (sb.st_size > 0 && S_ISREG (sb.st_mode))
2133     {
2134       int bytes_read;
2135
2136       while (total < (int) sb.st_size)
2137         {
2138           bytes_read = _dbus_read (fd, str,
2139                                    sb.st_size - total);
2140           if (bytes_read <= 0)
2141             {
2142               dbus_set_error (error, _dbus_error_from_errno (errno),
2143                               "Error reading \"%s\": %s",
2144                               filename_c,
2145                               _dbus_strerror (errno));
2146
2147               _dbus_verbose ("read() failed: %s",
2148                              _dbus_strerror (errno));
2149
2150               close (fd);
2151               _dbus_string_set_length (str, orig_len);
2152               return FALSE;
2153             }
2154           else
2155             total += bytes_read;
2156         }
2157
2158       close (fd);
2159       return TRUE;
2160     }
2161   else if (sb.st_size != 0)
2162     {
2163       _dbus_verbose ("Can only open regular files at the moment.\n");
2164       dbus_set_error (error, DBUS_ERROR_FAILED,
2165                       "\"%s\" is not a regular file",
2166                       filename_c);
2167       close (fd);
2168       return FALSE;
2169     }
2170   else
2171     {
2172       close (fd);
2173       return TRUE;
2174     }
2175 }
2176
2177 /**
2178  * Writes a string out to a file. If the file exists,
2179  * it will be atomically overwritten by the new data.
2180  *
2181  * @param str the string to write out
2182  * @param filename the file to save string to
2183  * @param error error to be filled in on failure
2184  * @returns #FALSE on failure
2185  */
2186 dbus_bool_t
2187 _dbus_string_save_to_file (const DBusString *str,
2188                            const DBusString *filename,
2189                            DBusError        *error)
2190 {
2191   int fd;
2192   int bytes_to_write;
2193   const char *filename_c;
2194   DBusString tmp_filename;
2195   const char *tmp_filename_c;
2196   int total;
2197   dbus_bool_t need_unlink;
2198   dbus_bool_t retval;
2199
2200   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2201
2202   fd = -1;
2203   retval = FALSE;
2204   need_unlink = FALSE;
2205
2206   if (!_dbus_string_init (&tmp_filename))
2207     {
2208       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2209       return FALSE;
2210     }
2211
2212   if (!_dbus_string_copy (filename, 0, &tmp_filename, 0))
2213     {
2214       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2215       _dbus_string_free (&tmp_filename);
2216       return FALSE;
2217     }
2218
2219   if (!_dbus_string_append (&tmp_filename, "."))
2220     {
2221       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2222       _dbus_string_free (&tmp_filename);
2223       return FALSE;
2224     }
2225
2226 #define N_TMP_FILENAME_RANDOM_BYTES 8
2227   if (!_dbus_generate_random_ascii (&tmp_filename, N_TMP_FILENAME_RANDOM_BYTES))
2228     {
2229       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
2230       _dbus_string_free (&tmp_filename);
2231       return FALSE;
2232     }
2233
2234   filename_c = _dbus_string_get_const_data (filename);
2235   tmp_filename_c = _dbus_string_get_const_data (&tmp_filename);
2236
2237   fd = open (tmp_filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
2238              0600);
2239   if (fd < 0)
2240     {
2241       dbus_set_error (error, _dbus_error_from_errno (errno),
2242                       "Could not create %s: %s", tmp_filename_c,
2243                       _dbus_strerror (errno));
2244       goto out;
2245     }
2246
2247   need_unlink = TRUE;
2248
2249   total = 0;
2250   bytes_to_write = _dbus_string_get_length (str);
2251
2252   while (total < bytes_to_write)
2253     {
2254       int bytes_written;
2255
2256       bytes_written = _dbus_write (fd, str, total,
2257                                    bytes_to_write - total);
2258
2259       if (bytes_written <= 0)
2260         {
2261           dbus_set_error (error, _dbus_error_from_errno (errno),
2262                           "Could not write to %s: %s", tmp_filename_c,
2263                           _dbus_strerror (errno));
2264
2265           goto out;
2266         }
2267
2268       total += bytes_written;
2269     }
2270
2271   if (close (fd) < 0)
2272     {
2273       dbus_set_error (error, _dbus_error_from_errno (errno),
2274                       "Could not close file %s: %s",
2275                       tmp_filename_c, _dbus_strerror (errno));
2276
2277       goto out;
2278     }
2279
2280   fd = -1;
2281
2282   if (rename (tmp_filename_c, filename_c) < 0)
2283     {
2284       dbus_set_error (error, _dbus_error_from_errno (errno),
2285                       "Could not rename %s to %s: %s",
2286                       tmp_filename_c, filename_c,
2287                       _dbus_strerror (errno));
2288
2289       goto out;
2290     }
2291
2292   need_unlink = FALSE;
2293
2294   retval = TRUE;
2295
2296  out:
2297   /* close first, then unlink, to prevent ".nfs34234235" garbage
2298    * files
2299    */
2300
2301   if (fd >= 0)
2302     close (fd);
2303
2304   if (need_unlink && unlink (tmp_filename_c) < 0)
2305     _dbus_verbose ("Failed to unlink temp file %s: %s\n",
2306                    tmp_filename_c, _dbus_strerror (errno));
2307
2308   _dbus_string_free (&tmp_filename);
2309
2310   if (!retval)
2311     _DBUS_ASSERT_ERROR_IS_SET (error);
2312
2313   return retval;
2314 }
2315
2316 /** Creates the given file, failing if the file already exists.
2317  *
2318  * @param filename the filename
2319  * @param error error location
2320  * @returns #TRUE if we created the file and it didn't exist
2321  */
2322 dbus_bool_t
2323 _dbus_create_file_exclusively (const DBusString *filename,
2324                                DBusError        *error)
2325 {
2326   int fd;
2327   const char *filename_c;
2328
2329   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2330
2331   filename_c = _dbus_string_get_const_data (filename);
2332
2333   fd = open (filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
2334              0600);
2335   if (fd < 0)
2336     {
2337       dbus_set_error (error,
2338                       DBUS_ERROR_FAILED,
2339                       "Could not create file %s: %s\n",
2340                       filename_c,
2341                       _dbus_strerror (errno));
2342       return FALSE;
2343     }
2344
2345   if (close (fd) < 0)
2346     {
2347       dbus_set_error (error,
2348                       DBUS_ERROR_FAILED,
2349                       "Could not close file %s: %s\n",
2350                       filename_c,
2351                       _dbus_strerror (errno));
2352       return FALSE;
2353     }
2354
2355   return TRUE;
2356 }
2357
2358 /**
2359  * Deletes the given file.
2360  *
2361  * @param filename the filename
2362  * @param error error location
2363  *
2364  * @returns #TRUE if unlink() succeeded
2365  */
2366 dbus_bool_t
2367 _dbus_delete_file (const DBusString *filename,
2368                    DBusError        *error)
2369 {
2370   const char *filename_c;
2371
2372   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2373
2374   filename_c = _dbus_string_get_const_data (filename);
2375
2376   if (unlink (filename_c) < 0)
2377     {
2378       dbus_set_error (error, DBUS_ERROR_FAILED,
2379                       "Failed to delete file %s: %s\n",
2380                       filename_c, _dbus_strerror (errno));
2381       return FALSE;
2382     }
2383   else
2384     return TRUE;
2385 }
2386
2387 /**
2388  * Creates a directory; succeeds if the directory
2389  * is created or already existed.
2390  *
2391  * @param filename directory filename
2392  * @param error initialized error object
2393  * @returns #TRUE on success
2394  */
2395 dbus_bool_t
2396 _dbus_create_directory (const DBusString *filename,
2397                         DBusError        *error)
2398 {
2399   const char *filename_c;
2400
2401   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2402
2403   filename_c = _dbus_string_get_const_data (filename);
2404
2405   if (mkdir (filename_c, 0700) < 0)
2406     {
2407       if (errno == EEXIST)
2408         return TRUE;
2409
2410       dbus_set_error (error, DBUS_ERROR_FAILED,
2411                       "Failed to create directory %s: %s\n",
2412                       filename_c, _dbus_strerror (errno));
2413       return FALSE;
2414     }
2415   else
2416     return TRUE;
2417 }
2418
2419 /**
2420  * Removes a directory; Directory must be empty
2421  *
2422  * @param filename directory filename
2423  * @param error initialized error object
2424  * @returns #TRUE on success
2425  */
2426 dbus_bool_t
2427 _dbus_delete_directory (const DBusString *filename,
2428                         DBusError        *error)
2429 {
2430   const char *filename_c;
2431
2432   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2433
2434   filename_c = _dbus_string_get_const_data (filename);
2435
2436   if (rmdir (filename_c) != 0)
2437     {
2438       dbus_set_error (error, DBUS_ERROR_FAILED,
2439                       "Failed to remove directory %s: %s\n",
2440                       filename_c, _dbus_strerror (errno));
2441       return FALSE;
2442     }
2443
2444   return TRUE;
2445 }
2446
2447 /**
2448  * Appends the given filename to the given directory.
2449  *
2450  * @todo it might be cute to collapse multiple '/' such as "foo//"
2451  * concat "//bar"
2452  *
2453  * @param dir the directory name
2454  * @param next_component the filename
2455  * @returns #TRUE on success
2456  */
2457 dbus_bool_t
2458 _dbus_concat_dir_and_file (DBusString       *dir,
2459                            const DBusString *next_component)
2460 {
2461   dbus_bool_t dir_ends_in_slash;
2462   dbus_bool_t file_starts_with_slash;
2463
2464   if (_dbus_string_get_length (dir) == 0 ||
2465       _dbus_string_get_length (next_component) == 0)
2466     return TRUE;
2467
2468   dir_ends_in_slash = '/' == _dbus_string_get_byte (dir,
2469                                                     _dbus_string_get_length (dir) - 1);
2470
2471   file_starts_with_slash = '/' == _dbus_string_get_byte (next_component, 0);
2472
2473   if (dir_ends_in_slash && file_starts_with_slash)
2474     {
2475       _dbus_string_shorten (dir, 1);
2476     }
2477   else if (!(dir_ends_in_slash || file_starts_with_slash))
2478     {
2479       if (!_dbus_string_append_byte (dir, '/'))
2480         return FALSE;
2481     }
2482
2483   return _dbus_string_copy (next_component, 0, dir,
2484                             _dbus_string_get_length (dir));
2485 }
2486
2487 /**
2488  * Get the directory name from a complete filename
2489  * @param filename the filename
2490  * @param dirname string to append directory name to
2491  * @returns #FALSE if no memory
2492  */
2493 dbus_bool_t
2494 _dbus_string_get_dirname  (const DBusString *filename,
2495                            DBusString       *dirname)
2496 {
2497   int sep;
2498
2499   _dbus_assert (filename != dirname);
2500   _dbus_assert (filename != NULL);
2501   _dbus_assert (dirname != NULL);
2502
2503   /* Ignore any separators on the end */
2504   sep = _dbus_string_get_length (filename);
2505   if (sep == 0)
2506     return _dbus_string_append (dirname, "."); /* empty string passed in */
2507
2508   while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
2509     --sep;
2510
2511   _dbus_assert (sep >= 0);
2512
2513   if (sep == 0)
2514     return _dbus_string_append (dirname, "/");
2515
2516   /* Now find the previous separator */
2517   _dbus_string_find_byte_backward (filename, sep, '/', &sep);
2518   if (sep < 0)
2519     return _dbus_string_append (dirname, ".");
2520
2521   /* skip multiple separators */
2522   while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
2523     --sep;
2524
2525   _dbus_assert (sep >= 0);
2526
2527   if (sep == 0 &&
2528       _dbus_string_get_byte (filename, 0) == '/')
2529     return _dbus_string_append (dirname, "/");
2530   else
2531     return _dbus_string_copy_len (filename, 0, sep - 0,
2532                                   dirname, _dbus_string_get_length (dirname));
2533 }
2534
2535 /**
2536  * Checks whether the filename is an absolute path
2537  *
2538  * @param filename the filename
2539  * @returns #TRUE if an absolute path
2540  */
2541 dbus_bool_t
2542 _dbus_path_is_absolute (const DBusString *filename)
2543 {
2544   if (_dbus_string_get_length (filename) > 0)
2545     return _dbus_string_get_byte (filename, 0) == '/';
2546   else
2547     return FALSE;
2548 }
2549
2550 /**
2551  * Internals of directory iterator
2552  */
2553 struct DBusDirIter
2554 {
2555   DIR *d; /**< The DIR* from opendir() */
2556
2557 };
2558
2559 /**
2560  * Open a directory to iterate over.
2561  *
2562  * @param filename the directory name
2563  * @param error exception return object or #NULL
2564  * @returns new iterator, or #NULL on error
2565  */
2566 DBusDirIter*
2567 _dbus_directory_open (const DBusString *filename,
2568                       DBusError        *error)
2569 {
2570   DIR *d;
2571   DBusDirIter *iter;
2572   const char *filename_c;
2573
2574   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2575
2576   filename_c = _dbus_string_get_const_data (filename);
2577
2578   d = opendir (filename_c);
2579   if (d == NULL)
2580     {
2581       dbus_set_error (error, _dbus_error_from_errno (errno),
2582                       "Failed to read directory \"%s\": %s",
2583                       filename_c,
2584                       _dbus_strerror (errno));
2585       return NULL;
2586     }
2587   iter = dbus_new0 (DBusDirIter, 1);
2588   if (iter == NULL)
2589     {
2590       closedir (d);
2591       dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
2592                       "Could not allocate memory for directory iterator");
2593       return NULL;
2594     }
2595
2596   iter->d = d;
2597
2598   return iter;
2599 }
2600
2601 /**
2602  * Get next file in the directory. Will not return "." or ".."  on
2603  * UNIX. If an error occurs, the contents of "filename" are
2604  * undefined. The error is never set if the function succeeds.
2605  *
2606  * @todo for thread safety, I think we have to use
2607  * readdir_r(). (GLib has the same issue, should file a bug.)
2608  *
2609  * @param iter the iterator
2610  * @param filename string to be set to the next file in the dir
2611  * @param error return location for error
2612  * @returns #TRUE if filename was filled in with a new filename
2613  */
2614 dbus_bool_t
2615 _dbus_directory_get_next_file (DBusDirIter      *iter,
2616                                DBusString       *filename,
2617                                DBusError        *error)
2618 {
2619   struct dirent *ent;
2620
2621   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2622
2623  again:
2624   errno = 0;
2625   ent = readdir (iter->d);
2626   if (ent == NULL)
2627     {
2628       if (errno != 0)
2629         dbus_set_error (error,
2630                         _dbus_error_from_errno (errno),
2631                         "%s", _dbus_strerror (errno));
2632       return FALSE;
2633     }
2634   else if (ent->d_name[0] == '.' &&
2635            (ent->d_name[1] == '\0' ||
2636             (ent->d_name[1] == '.' && ent->d_name[2] == '\0')))
2637     goto again;
2638   else
2639     {
2640       _dbus_string_set_length (filename, 0);
2641       if (!_dbus_string_append (filename, ent->d_name))
2642         {
2643           dbus_set_error (error, DBUS_ERROR_NO_MEMORY,
2644                           "No memory to read directory entry");
2645           return FALSE;
2646         }
2647       else
2648         return TRUE;
2649     }
2650 }
2651
2652 /**
2653  * Closes a directory iteration.
2654  */
2655 void
2656 _dbus_directory_close (DBusDirIter *iter)
2657 {
2658   closedir (iter->d);
2659   dbus_free (iter);
2660 }
2661
2662 static dbus_bool_t
2663 pseudorandom_generate_random_bytes (DBusString *str,
2664                                     int         n_bytes)
2665 {
2666   int old_len;
2667   unsigned long tv_usec;
2668   int i;
2669
2670   old_len = _dbus_string_get_length (str);
2671
2672   /* fall back to pseudorandom */
2673   _dbus_verbose ("Falling back to pseudorandom for %d bytes\n",
2674                  n_bytes);
2675
2676   _dbus_get_current_time (NULL, &tv_usec);
2677   srand (tv_usec);
2678
2679   i = 0;
2680   while (i < n_bytes)
2681     {
2682       double r;
2683       unsigned int b;
2684
2685       r = rand ();
2686       b = (r / (double) RAND_MAX) * 255.0;
2687
2688       if (!_dbus_string_append_byte (str, b))
2689         goto failed;
2690
2691       ++i;
2692     }
2693
2694   return TRUE;
2695
2696  failed:
2697   _dbus_string_set_length (str, old_len);
2698   return FALSE;
2699 }
2700
2701 /**
2702  * Generates the given number of random bytes,
2703  * using the best mechanism we can come up with.
2704  *
2705  * @param str the string
2706  * @param n_bytes the number of random bytes to append to string
2707  * @returns #TRUE on success, #FALSE if no memory
2708  */
2709 dbus_bool_t
2710 _dbus_generate_random_bytes (DBusString *str,
2711                              int         n_bytes)
2712 {
2713   int old_len;
2714   int fd;
2715
2716   /* FALSE return means "no memory", if it could
2717    * mean something else then we'd need to return
2718    * a DBusError. So we always fall back to pseudorandom
2719    * if the I/O fails.
2720    */
2721
2722   old_len = _dbus_string_get_length (str);
2723   fd = -1;
2724
2725   /* note, urandom on linux will fall back to pseudorandom */
2726   fd = open ("/dev/urandom", O_RDONLY);
2727   if (fd < 0)
2728     return pseudorandom_generate_random_bytes (str, n_bytes);
2729
2730   if (_dbus_read (fd, str, n_bytes) != n_bytes)
2731     {
2732       close (fd);
2733       _dbus_string_set_length (str, old_len);
2734       return pseudorandom_generate_random_bytes (str, n_bytes);
2735     }
2736
2737   _dbus_verbose ("Read %d bytes from /dev/urandom\n",
2738                  n_bytes);
2739
2740   close (fd);
2741
2742   return TRUE;
2743 }
2744
2745 /**
2746  * Generates the given number of random bytes, where the bytes are
2747  * chosen from the alphanumeric ASCII subset.
2748  *
2749  * @param str the string
2750  * @param n_bytes the number of random ASCII bytes to append to string
2751  * @returns #TRUE on success, #FALSE if no memory or other failure
2752  */
2753 dbus_bool_t
2754 _dbus_generate_random_ascii (DBusString *str,
2755                              int         n_bytes)
2756 {
2757   static const char letters[] =
2758     "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
2759   int i;
2760   int len;
2761
2762   if (!_dbus_generate_random_bytes (str, n_bytes))
2763     return FALSE;
2764
2765   len = _dbus_string_get_length (str);
2766   i = len - n_bytes;
2767   while (i < len)
2768     {
2769       _dbus_string_set_byte (str, i,
2770                              letters[_dbus_string_get_byte (str, i) %
2771                                      (sizeof (letters) - 1)]);
2772
2773       ++i;
2774     }
2775
2776   _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes,
2777                                              n_bytes));
2778
2779   return TRUE;
2780 }
2781
2782 /**
2783  * A wrapper around strerror() because some platforms
2784  * may be lame and not have strerror().
2785  *
2786  * @param error_number errno.
2787  * @returns error description.
2788  */
2789 const char*
2790 _dbus_strerror (int error_number)
2791 {
2792   const char *msg;
2793
2794   msg = strerror (error_number);
2795   if (msg == NULL)
2796     msg = "unknown";
2797
2798   return msg;
2799 }
2800
2801 /**
2802  * signal (SIGPIPE, SIG_IGN);
2803  */
2804 void
2805 _dbus_disable_sigpipe (void)
2806 {
2807   signal (SIGPIPE, SIG_IGN);
2808 }
2809
2810 /**
2811  * Sets the file descriptor to be close
2812  * on exec. Should be called for all file
2813  * descriptors in D-BUS code.
2814  *
2815  * @param fd the file descriptor
2816  */
2817 void
2818 _dbus_fd_set_close_on_exec (int fd)
2819 {
2820   int val;
2821
2822   val = fcntl (fd, F_GETFD, 0);
2823
2824   if (val < 0)
2825     return;
2826
2827   val |= FD_CLOEXEC;
2828
2829   fcntl (fd, F_SETFD, val);
2830 }
2831
2832 /**
2833  * Converts a UNIX errno into a #DBusError name.
2834  *
2835  * @todo should cover more errnos, specifically those
2836  * from open().
2837  *
2838  * @param error_number the errno.
2839  * @returns an error name
2840  */
2841 const char*
2842 _dbus_error_from_errno (int error_number)
2843 {
2844   switch (error_number)
2845     {
2846     case 0:
2847       return DBUS_ERROR_FAILED;
2848
2849 #ifdef EPROTONOSUPPORT
2850     case EPROTONOSUPPORT:
2851       return DBUS_ERROR_NOT_SUPPORTED;
2852 #endif
2853 #ifdef EAFNOSUPPORT
2854     case EAFNOSUPPORT:
2855       return DBUS_ERROR_NOT_SUPPORTED;
2856 #endif
2857 #ifdef ENFILE
2858     case ENFILE:
2859       return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */
2860 #endif
2861 #ifdef EMFILE
2862     case EMFILE:
2863       return DBUS_ERROR_LIMITS_EXCEEDED;
2864 #endif
2865 #ifdef EACCES
2866     case EACCES:
2867       return DBUS_ERROR_ACCESS_DENIED;
2868 #endif
2869 #ifdef EPERM
2870     case EPERM:
2871       return DBUS_ERROR_ACCESS_DENIED;
2872 #endif
2873 #ifdef ENOBUFS
2874     case ENOBUFS:
2875       return DBUS_ERROR_NO_MEMORY;
2876 #endif
2877 #ifdef ENOMEM
2878     case ENOMEM:
2879       return DBUS_ERROR_NO_MEMORY;
2880 #endif
2881 #ifdef EINVAL
2882     case EINVAL:
2883       return DBUS_ERROR_FAILED;
2884 #endif
2885 #ifdef EBADF
2886     case EBADF:
2887       return DBUS_ERROR_FAILED;
2888 #endif
2889 #ifdef EFAULT
2890     case EFAULT:
2891       return DBUS_ERROR_FAILED;
2892 #endif
2893 #ifdef ENOTSOCK
2894     case ENOTSOCK:
2895       return DBUS_ERROR_FAILED;
2896 #endif
2897 #ifdef EISCONN
2898     case EISCONN:
2899       return DBUS_ERROR_FAILED;
2900 #endif
2901 #ifdef ECONNREFUSED
2902     case ECONNREFUSED:
2903       return DBUS_ERROR_NO_SERVER;
2904 #endif
2905 #ifdef ETIMEDOUT
2906     case ETIMEDOUT:
2907       return DBUS_ERROR_TIMEOUT;
2908 #endif
2909 #ifdef ENETUNREACH
2910     case ENETUNREACH:
2911       return DBUS_ERROR_NO_NETWORK;
2912 #endif
2913 #ifdef EADDRINUSE
2914     case EADDRINUSE:
2915       return DBUS_ERROR_ADDRESS_IN_USE;
2916 #endif
2917 #ifdef EEXIST
2918     case EEXIST:
2919       return DBUS_ERROR_FILE_NOT_FOUND;
2920 #endif
2921 #ifdef ENOENT
2922     case ENOENT:
2923       return DBUS_ERROR_FILE_NOT_FOUND;
2924 #endif
2925     }
2926
2927   return DBUS_ERROR_FAILED;
2928 }
2929
2930 /**
2931  * Exit the process, returning the given value.
2932  *
2933  * @param code the exit code
2934  */
2935 void
2936 _dbus_exit (int code)
2937 {
2938   _exit (code);
2939 }
2940
2941 /**
2942  * stat() wrapper.
2943  *
2944  * @param filename the filename to stat
2945  * @param statbuf the stat info to fill in
2946  * @param error return location for error
2947  * @returns #FALSE if error was set
2948  */
2949 dbus_bool_t
2950 _dbus_stat (const DBusString *filename,
2951             DBusStat         *statbuf,
2952             DBusError        *error)
2953 {
2954   const char *filename_c;
2955   struct stat sb;
2956
2957   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
2958
2959   filename_c = _dbus_string_get_const_data (filename);
2960
2961   if (stat (filename_c, &sb) < 0)
2962     {
2963       dbus_set_error (error, _dbus_error_from_errno (errno),
2964                       "%s", _dbus_strerror (errno));
2965       return FALSE;
2966     }
2967
2968   statbuf->mode = sb.st_mode;
2969   statbuf->nlink = sb.st_nlink;
2970   statbuf->uid = sb.st_uid;
2971   statbuf->gid = sb.st_gid;
2972   statbuf->size = sb.st_size;
2973   statbuf->atime = sb.st_atime;
2974   statbuf->mtime = sb.st_mtime;
2975   statbuf->ctime = sb.st_ctime;
2976
2977   return TRUE;
2978 }
2979
2980 /**
2981  * Creates a full-duplex pipe (as in socketpair()).
2982  * Sets both ends of the pipe nonblocking.
2983  *
2984  * @param fd1 return location for one end
2985  * @param fd2 return location for the other end
2986  * @param blocking #TRUE if pipe should be blocking
2987  * @param error error return
2988  * @returns #FALSE on failure (if error is set)
2989  */
2990 dbus_bool_t
2991 _dbus_full_duplex_pipe (int        *fd1,
2992                         int        *fd2,
2993                         dbus_bool_t blocking,
2994                         DBusError  *error)
2995 {
2996 #ifdef HAVE_SOCKETPAIR
2997   int fds[2];
2998
2999   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3000
3001   if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) < 0)
3002     {
3003       dbus_set_error (error, _dbus_error_from_errno (errno),
3004                       "Could not create full-duplex pipe");
3005       return FALSE;
3006     }
3007
3008   if (!blocking &&
3009       (!_dbus_set_fd_nonblocking (fds[0], NULL) ||
3010        !_dbus_set_fd_nonblocking (fds[1], NULL)))
3011     {
3012       dbus_set_error (error, _dbus_error_from_errno (errno),
3013                       "Could not set full-duplex pipe nonblocking");
3014
3015       close (fds[0]);
3016       close (fds[1]);
3017
3018       return FALSE;
3019     }
3020
3021   *fd1 = fds[0];
3022   *fd2 = fds[1];
3023
3024   return TRUE;
3025 #else
3026   _dbus_warn ("_dbus_full_duplex_pipe() not implemented on this OS\n");
3027   dbus_set_error (error, DBUS_ERROR_FAILED,
3028                   "_dbus_full_duplex_pipe() not implemented on this OS");
3029   return FALSE;
3030 #endif
3031 }
3032
3033 /**
3034  * Closes a file descriptor.
3035  *
3036  * @param fd the file descriptor
3037  * @param error error object
3038  * @returns #FALSE if error set
3039  */
3040 dbus_bool_t
3041 _dbus_close (int        fd,
3042              DBusError *error)
3043 {
3044   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3045
3046  again:
3047   if (close (fd) < 0)
3048     {
3049       if (errno == EINTR)
3050         goto again;
3051
3052       dbus_set_error (error, _dbus_error_from_errno (errno),
3053                       "Could not close fd %d", fd);
3054       return FALSE;
3055     }
3056
3057   return TRUE;
3058 }
3059
3060 /**
3061  * Sets a file descriptor to be nonblocking.
3062  *
3063  * @param fd the file descriptor.
3064  * @param error address of error location.
3065  * @returns #TRUE on success.
3066  */
3067 dbus_bool_t
3068 _dbus_set_fd_nonblocking (int             fd,
3069                           DBusError      *error)
3070 {
3071   int val;
3072
3073   _DBUS_ASSERT_ERROR_IS_CLEAR (error);
3074
3075   val = fcntl (fd, F_GETFL, 0);
3076   if (val < 0)
3077     {
3078       dbus_set_error (error, _dbus_error_from_errno (errno),
3079                       "Failed to get flags from file descriptor %d: %s",
3080                       fd, _dbus_strerror (errno));
3081       _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
3082                      _dbus_strerror (errno));
3083       return FALSE;
3084     }
3085
3086   if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
3087     {
3088       dbus_set_error (error, _dbus_error_from_errno (errno),
3089                       "Failed to set nonblocking flag of file descriptor %d: %s",
3090                       fd, _dbus_strerror (errno));
3091       _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
3092                      fd, _dbus_strerror (errno));
3093
3094       return FALSE;
3095     }
3096
3097   return TRUE;
3098 }
3099
3100 /**
3101  * On GNU libc systems, print a crude backtrace to the verbose log.
3102  * On other systems, print "no backtrace support"
3103  *
3104  */
3105 void
3106 _dbus_print_backtrace (void)
3107 {
3108 #if defined (HAVE_BACKTRACE) && defined (DBUS_ENABLE_VERBOSE_MODE)
3109   void *bt[500];
3110   int bt_size;
3111   int i;
3112   char **syms;
3113
3114   bt_size = backtrace (bt, 500);
3115
3116   syms = backtrace_symbols (bt, bt_size);
3117
3118   i = 0;
3119   while (i < bt_size)
3120     {
3121       _dbus_verbose ("  %s\n", syms[i]);
3122       ++i;
3123     }
3124
3125   free (syms);
3126 #else
3127   _dbus_verbose ("  D-BUS not compiled with backtrace support\n");
3128 #endif
3129 }
3130
3131 /**
3132  * Does the chdir, fork, setsid, etc. to become a daemon process.
3133  *
3134  * @param pidfile #NULL, or pidfile to create
3135  * @param error return location for errors
3136  * @returns #FALSE on failure
3137  */
3138 dbus_bool_t
3139 _dbus_become_daemon (const DBusString *pidfile,
3140                      DBusError        *error)
3141 {
3142   const char *s;
3143   pid_t child_pid;
3144   int dev_null_fd;
3145
3146   _dbus_verbose ("Becoming a daemon...\n");
3147
3148   _dbus_verbose ("chdir to /\n");
3149   if (chdir ("/") < 0)
3150     {
3151       dbus_set_error (error, DBUS_ERROR_FAILED,
3152                       "Could not chdir() to root directory");
3153       return FALSE;
3154     }
3155
3156   _dbus_verbose ("forking...\n");
3157   switch ((child_pid = fork ()))
3158     {
3159     case -1:
3160       _dbus_verbose ("fork failed\n");
3161       dbus_set_error (error, _dbus_error_from_errno (errno),
3162                       "Failed to fork daemon: %s", _dbus_strerror (errno));
3163       return FALSE;
3164       break;
3165
3166     case 0:
3167       _dbus_verbose ("in child, closing std file descriptors\n");
3168
3169       /* silently ignore failures here, if someone
3170        * doesn't have /dev/null we may as well try
3171        * to continue anyhow
3172        */
3173
3174       dev_null_fd = open ("/dev/null", O_RDWR);
3175       if (dev_null_fd >= 0)
3176         {
3177           dup2 (dev_null_fd, 0);
3178           dup2 (dev_null_fd, 1);
3179
3180           s = _dbus_getenv ("DBUS_DEBUG_OUTPUT");
3181           if (s == NULL || *s == '\0')
3182             dup2 (dev_null_fd, 2);
3183           else
3184             _dbus_verbose ("keeping stderr open due to DBUS_DEBUG_OUTPUT\n");
3185         }
3186
3187       /* Get a predictable umask */
3188       _dbus_verbose ("setting umask\n");
3189       umask (022);
3190       break;
3191
3192     default:
3193       if (pidfile)
3194         {
3195           _dbus_verbose ("parent writing pid file\n");
3196           if (!_dbus_write_pid_file (pidfile,
3197                                      child_pid,
3198                                      error))
3199             {
3200               _dbus_verbose ("pid file write failed, killing child\n");
3201               kill (child_pid, SIGTERM);
3202               return FALSE;
3203             }
3204         }
3205       _dbus_verbose ("parent exiting\n");
3206       _exit (0);
3207       break;
3208     }
3209
3210   _dbus_verbose ("calling setsid()\n");
3211   if (setsid () == -1)
3212     _dbus_assert_not_reached ("setsid() failed");
3213
3214   return TRUE;
3215 }
3216
3217 /**
3218  * Creates a file containing the process ID.
3219  *
3220  * @param filename the filename to write to
3221  * @param pid our process ID
3222  * @param error return location for errors
3223  * @returns #FALSE on failure
3224  */
3225 dbus_bool_t
3226 _dbus_write_pid_file (const DBusString *filename,
3227                       unsigned long     pid,
3228                       DBusError        *error)
3229 {
3230   const char *cfilename;
3231   int fd;
3232   FILE *f;
3233
3234   cfilename = _dbus_string_get_const_data (filename);
3235
3236   fd = open (cfilename, O_WRONLY|O_CREAT|O_EXCL|O_BINARY, 0644);
3237
3238   if (fd < 0)
3239     {
3240       dbus_set_error (error, _dbus_error_from_errno (errno),
3241                       "Failed to open \"%s\": %s", cfilename,
3242                       _dbus_strerror (errno));
3243       return FALSE;
3244     }
3245
3246   if ((f = fdopen (fd, "w")) == NULL)
3247     {
3248       dbus_set_error (error, _dbus_error_from_errno (errno),
3249                       "Failed to fdopen fd %d: %s", fd, _dbus_strerror (errno));
3250       close (fd);
3251       return FALSE;
3252     }
3253
3254   if (fprintf (f, "%lu\n", pid) < 0)
3255     {
3256       dbus_set_error (error, _dbus_error_from_errno (errno),
3257                       "Failed to write to \"%s\": %s", cfilename,
3258                       _dbus_strerror (errno));
3259       return FALSE;
3260     }
3261
3262   if (fclose (f) == EOF)
3263     {
3264       dbus_set_error (error, _dbus_error_from_errno (errno),
3265                       "Failed to close \"%s\": %s", cfilename,
3266                       _dbus_strerror (errno));
3267       return FALSE;
3268     }
3269
3270   return TRUE;
3271 }
3272
3273 /**
3274  * Changes the user and group the bus is running as.
3275  *
3276  * @param uid the new user ID
3277  * @param gid the new group ID
3278  * @param error return location for errors
3279  * @returns #FALSE on failure
3280  */
3281 dbus_bool_t
3282 _dbus_change_identity  (dbus_uid_t     uid,
3283                         dbus_gid_t     gid,
3284                         DBusError     *error)
3285 {
3286   /* setgroups() only works if we are a privileged process,
3287    * so we don't return error on failure; the only possible
3288    * failure is that we don't have perms to do it.
3289    * FIXME not sure this is right, maybe if setuid()
3290    * is going to work then setgroups() should also work.
3291    */
3292   if (setgroups (0, NULL) < 0)
3293     _dbus_warn ("Failed to drop supplementary groups: %s\n",
3294                 _dbus_strerror (errno));
3295
3296   /* Set GID first, or the setuid may remove our permission
3297    * to change the GID
3298    */
3299   if (setgid (gid) < 0)
3300     {
3301       dbus_set_error (error, _dbus_error_from_errno (errno),
3302                       "Failed to set GID to %lu: %s", gid,
3303                       _dbus_strerror (errno));
3304       return FALSE;
3305     }
3306
3307   if (setuid (uid) < 0)
3308     {
3309       dbus_set_error (error, _dbus_error_from_errno (errno),
3310                       "Failed to set UID to %lu: %s", uid,
3311                       _dbus_strerror (errno));
3312       return FALSE;
3313     }
3314
3315   return TRUE;
3316 }
3317
3318 /** Installs a UNIX signal handler
3319  *
3320  * @param sig the signal to handle
3321  * @param handler the handler
3322  */
3323 void
3324 _dbus_set_signal_handler (int               sig,
3325                           DBusSignalHandler handler)
3326 {
3327   struct sigaction act;
3328   sigset_t empty_mask;
3329
3330   sigemptyset (&empty_mask);
3331   act.sa_handler = handler;
3332   act.sa_mask    = empty_mask;
3333   act.sa_flags   = 0;
3334   sigaction (sig,  &act, 0);
3335 }
3336
3337 /** Checks if a file exists
3338 *
3339 * @param file full path to the file
3340 * @returns #TRUE if file exists
3341 */
3342 dbus_bool_t
3343 _dbus_file_exists (const char *file)
3344 {
3345   return (access (file, F_OK) == 0);
3346 }
3347
3348 /** Checks if user is at the console
3349 *
3350 * @param username user to check
3351 * @param error return location for errors
3352 * @returns #TRUE is the user is at the consolei and there are no errors
3353 */
3354 dbus_bool_t
3355 _dbus_user_at_console (const char *username,
3356                        DBusError  *error)
3357 {
3358
3359   DBusString f;
3360   dbus_bool_t result;
3361
3362   if (!_dbus_string_init (&f))
3363     {
3364       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
3365       return FALSE;
3366     }
3367
3368   if (!_dbus_string_append (&f, DBUS_CONSOLE_DIR))
3369     {
3370       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
3371       return FALSE;
3372     }
3373
3374
3375   if (!_dbus_string_append (&f, username))
3376     {
3377       dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
3378       return FALSE;
3379     }
3380
3381   result = _dbus_file_exists (_dbus_string_get_const_data (&f));
3382   _dbus_string_free (&f);
3383
3384   return result;
3385 }
3386
3387 #ifdef DBUS_BUILD_TESTS
3388 #include <stdlib.h>
3389 static void
3390 check_dirname (const char *filename,
3391                const char *dirname)
3392 {
3393   DBusString f, d;
3394
3395   _dbus_string_init_const (&f, filename);
3396
3397   if (!_dbus_string_init (&d))
3398     _dbus_assert_not_reached ("no memory");
3399
3400   if (!_dbus_string_get_dirname (&f, &d))
3401     _dbus_assert_not_reached ("no memory");
3402
3403   if (!_dbus_string_equal_c_str (&d, dirname))
3404     {
3405       _dbus_warn ("For filename \"%s\" got dirname \"%s\" and expected \"%s\"\n",
3406                   filename,
3407                   _dbus_string_get_const_data (&d),
3408                   dirname);
3409       exit (1);
3410     }
3411
3412   _dbus_string_free (&d);
3413 }
3414
3415 static void
3416 check_path_absolute (const char *path,
3417                      dbus_bool_t expected)
3418 {
3419   DBusString p;
3420
3421   _dbus_string_init_const (&p, path);
3422
3423   if (_dbus_path_is_absolute (&p) != expected)
3424     {
3425       _dbus_warn ("For path \"%s\" expected absolute = %d got %d\n",
3426                   path, expected, _dbus_path_is_absolute (&p));
3427       exit (1);
3428     }
3429 }
3430
3431 /**
3432  * Unit test for dbus-sysdeps.c.
3433  *
3434  * @returns #TRUE on success.
3435  */
3436 dbus_bool_t
3437 _dbus_sysdeps_test (void)
3438 {
3439   DBusString str;
3440   double val;
3441   int pos;
3442
3443   check_dirname ("foo", ".");
3444   check_dirname ("foo/bar", "foo");
3445   check_dirname ("foo//bar", "foo");
3446   check_dirname ("foo///bar", "foo");
3447   check_dirname ("foo/bar/", "foo");
3448   check_dirname ("foo//bar/", "foo");
3449   check_dirname ("foo///bar/", "foo");
3450   check_dirname ("foo/bar//", "foo");
3451   check_dirname ("foo//bar////", "foo");
3452   check_dirname ("foo///bar///////", "foo");
3453   check_dirname ("/foo", "/");
3454   check_dirname ("////foo", "/");
3455   check_dirname ("/foo/bar", "/foo");
3456   check_dirname ("/foo//bar", "/foo");
3457   check_dirname ("/foo///bar", "/foo");
3458   check_dirname ("/", "/");
3459   check_dirname ("///", "/");
3460   check_dirname ("", ".");
3461
3462
3463   _dbus_string_init_const (&str, "3.5");
3464   if (!_dbus_string_parse_double (&str,
3465                                   0, &val, &pos))
3466     {
3467       _dbus_warn ("Failed to parse double");
3468       exit (1);
3469     }
3470   if (val != 3.5)
3471     {
3472       _dbus_warn ("Failed to parse 3.5 correctly, got: %f", val);
3473       exit (1);
3474     }
3475   if (pos != 3)
3476     {
3477       _dbus_warn ("_dbus_string_parse_double of \"3.5\" returned wrong position %d", pos);
3478       exit (1);
3479     }
3480
3481   _dbus_string_init_const (&str, "0xff");
3482   if (!_dbus_string_parse_double (&str,
3483                                   0, &val, &pos))
3484     {
3485       _dbus_warn ("Failed to parse double");
3486       exit (1);
3487     }
3488   if (val != 0xff)
3489     {
3490       _dbus_warn ("Failed to parse 0xff correctly, got: %f", val);
3491       exit (1);
3492     }
3493   if (pos != 4)
3494     {
3495       _dbus_warn ("_dbus_string_parse_double of \"0xff\" returned wrong position %d", pos);
3496       exit (1);
3497     }
3498
3499   check_path_absolute ("/", TRUE);
3500   check_path_absolute ("/foo", TRUE);
3501   check_path_absolute ("", FALSE);
3502   check_path_absolute ("foo", FALSE);
3503   check_path_absolute ("foo/bar", FALSE);
3504
3505   return TRUE;
3506 }
3507 #endif /* DBUS_BUILD_TESTS */
3508
3509 /** @} end of sysdeps */
3510