00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #define _GNU_SOURCE
00026
00027 #include "dbus-internals.h"
00028 #include "dbus-sysdeps.h"
00029 #include "dbus-sysdeps-unix.h"
00030 #include "dbus-threads.h"
00031 #include "dbus-protocol.h"
00032 #include "dbus-transport.h"
00033 #include "dbus-string.h"
00034 #include "dbus-userdb.h"
00035 #include "dbus-list.h"
00036 #include "dbus-credentials.h"
00037
00038 #include <sys/types.h>
00039 #include <stdlib.h>
00040 #include <string.h>
00041 #include <signal.h>
00042 #include <unistd.h>
00043 #include <stdio.h>
00044 #include <fcntl.h>
00045 #include <sys/socket.h>
00046 #include <dirent.h>
00047 #include <sys/un.h>
00048 #include <pwd.h>
00049 #include <time.h>
00050 #include <locale.h>
00051 #include <sys/time.h>
00052 #include <sys/stat.h>
00053 #include <sys/wait.h>
00054 #include <netinet/in.h>
00055 #include <netdb.h>
00056 #include <grp.h>
00057
00058 #ifdef HAVE_ERRNO_H
00059 #include <errno.h>
00060 #endif
00061 #ifdef HAVE_WRITEV
00062 #include <sys/uio.h>
00063 #endif
00064 #ifdef HAVE_POLL
00065 #include <sys/poll.h>
00066 #endif
00067 #ifdef HAVE_BACKTRACE
00068 #include <execinfo.h>
00069 #endif
00070 #ifdef HAVE_GETPEERUCRED
00071 #include <ucred.h>
00072 #endif
00073
00074 #ifdef HAVE_ADT
00075 #include <bsm/adt.h>
00076 #endif
00077
00078 #ifndef O_BINARY
00079 #define O_BINARY 0
00080 #endif
00081
00082 #ifndef _AI_ADDRCONFIG
00083 #define _AI_ADDRCONFIG 0
00084 #endif
00085
00086 #ifndef HAVE_SOCKLEN_T
00087 #define socklen_t int
00088 #endif
00089
00090 static dbus_bool_t
00091 _dbus_open_socket (int *fd_p,
00092 int domain,
00093 int type,
00094 int protocol,
00095 DBusError *error)
00096 {
00097 *fd_p = socket (domain, type, protocol);
00098 if (*fd_p >= 0)
00099 {
00100 _dbus_verbose ("socket fd %d opened\n", *fd_p);
00101 return TRUE;
00102 }
00103 else
00104 {
00105 dbus_set_error(error,
00106 _dbus_error_from_errno (errno),
00107 "Failed to open socket: %s",
00108 _dbus_strerror (errno));
00109 return FALSE;
00110 }
00111 }
00112
00113 dbus_bool_t
00114 _dbus_open_tcp_socket (int *fd,
00115 DBusError *error)
00116 {
00117 return _dbus_open_socket(fd, AF_INET, SOCK_STREAM, 0, error);
00118 }
00119
00127 dbus_bool_t
00128 _dbus_open_unix_socket (int *fd,
00129 DBusError *error)
00130 {
00131 return _dbus_open_socket(fd, PF_UNIX, SOCK_STREAM, 0, error);
00132 }
00133
00142 dbus_bool_t
00143 _dbus_close_socket (int fd,
00144 DBusError *error)
00145 {
00146 return _dbus_close (fd, error);
00147 }
00148
00158 int
00159 _dbus_read_socket (int fd,
00160 DBusString *buffer,
00161 int count)
00162 {
00163 return _dbus_read (fd, buffer, count);
00164 }
00165
00176 int
00177 _dbus_write_socket (int fd,
00178 const DBusString *buffer,
00179 int start,
00180 int len)
00181 {
00182 return _dbus_write (fd, buffer, start, len);
00183 }
00184
00195 int
00196 _dbus_pipe_write (DBusPipe *pipe,
00197 const DBusString *buffer,
00198 int start,
00199 int len,
00200 DBusError *error)
00201 {
00202 int written;
00203
00204 written = _dbus_write (pipe->fd_or_handle, buffer, start, len);
00205 if (written < 0)
00206 {
00207 dbus_set_error (error, DBUS_ERROR_FAILED,
00208 "Writing to pipe: %s\n",
00209 _dbus_strerror (errno));
00210 }
00211 return written;
00212 }
00213
00221 int
00222 _dbus_pipe_close (DBusPipe *pipe,
00223 DBusError *error)
00224 {
00225 if (_dbus_close (pipe->fd_or_handle, error) < 0)
00226 {
00227 return -1;
00228 }
00229 else
00230 {
00231 _dbus_pipe_invalidate (pipe);
00232 return 0;
00233 }
00234 }
00235
00249 int
00250 _dbus_write_socket_two (int fd,
00251 const DBusString *buffer1,
00252 int start1,
00253 int len1,
00254 const DBusString *buffer2,
00255 int start2,
00256 int len2)
00257 {
00258 return _dbus_write_two (fd, buffer1, start1, len1,
00259 buffer2, start2, len2);
00260 }
00261
00262
00279 int
00280 _dbus_read (int fd,
00281 DBusString *buffer,
00282 int count)
00283 {
00284 int bytes_read;
00285 int start;
00286 char *data;
00287
00288 _dbus_assert (count >= 0);
00289
00290 start = _dbus_string_get_length (buffer);
00291
00292 if (!_dbus_string_lengthen (buffer, count))
00293 {
00294 errno = ENOMEM;
00295 return -1;
00296 }
00297
00298 data = _dbus_string_get_data_len (buffer, start, count);
00299
00300 again:
00301
00302 bytes_read = read (fd, data, count);
00303
00304 if (bytes_read < 0)
00305 {
00306 if (errno == EINTR)
00307 goto again;
00308 else
00309 {
00310
00311 _dbus_string_set_length (buffer, start);
00312 return -1;
00313 }
00314 }
00315 else
00316 {
00317
00318 _dbus_string_set_length (buffer, start + bytes_read);
00319
00320 #if 0
00321 if (bytes_read > 0)
00322 _dbus_verbose_bytes_of_string (buffer, start, bytes_read);
00323 #endif
00324
00325 return bytes_read;
00326 }
00327 }
00328
00339 int
00340 _dbus_write (int fd,
00341 const DBusString *buffer,
00342 int start,
00343 int len)
00344 {
00345 const char *data;
00346 int bytes_written;
00347
00348 data = _dbus_string_get_const_data_len (buffer, start, len);
00349
00350 again:
00351
00352 bytes_written = write (fd, data, len);
00353
00354 if (bytes_written < 0 && errno == EINTR)
00355 goto again;
00356
00357 #if 0
00358 if (bytes_written > 0)
00359 _dbus_verbose_bytes_of_string (buffer, start, bytes_written);
00360 #endif
00361
00362 return bytes_written;
00363 }
00364
00385 int
00386 _dbus_write_two (int fd,
00387 const DBusString *buffer1,
00388 int start1,
00389 int len1,
00390 const DBusString *buffer2,
00391 int start2,
00392 int len2)
00393 {
00394 _dbus_assert (buffer1 != NULL);
00395 _dbus_assert (start1 >= 0);
00396 _dbus_assert (start2 >= 0);
00397 _dbus_assert (len1 >= 0);
00398 _dbus_assert (len2 >= 0);
00399
00400 #ifdef HAVE_WRITEV
00401 {
00402 struct iovec vectors[2];
00403 const char *data1;
00404 const char *data2;
00405 int bytes_written;
00406
00407 data1 = _dbus_string_get_const_data_len (buffer1, start1, len1);
00408
00409 if (buffer2 != NULL)
00410 data2 = _dbus_string_get_const_data_len (buffer2, start2, len2);
00411 else
00412 {
00413 data2 = NULL;
00414 start2 = 0;
00415 len2 = 0;
00416 }
00417
00418 vectors[0].iov_base = (char*) data1;
00419 vectors[0].iov_len = len1;
00420 vectors[1].iov_base = (char*) data2;
00421 vectors[1].iov_len = len2;
00422
00423 again:
00424
00425 bytes_written = writev (fd,
00426 vectors,
00427 data2 ? 2 : 1);
00428
00429 if (bytes_written < 0 && errno == EINTR)
00430 goto again;
00431
00432 return bytes_written;
00433 }
00434 #else
00435 {
00436 int ret1;
00437
00438 ret1 = _dbus_write (fd, buffer1, start1, len1);
00439 if (ret1 == len1 && buffer2 != NULL)
00440 {
00441 ret2 = _dbus_write (fd, buffer2, start2, len2);
00442 if (ret2 < 0)
00443 ret2 = 0;
00444
00445 return ret1 + ret2;
00446 }
00447 else
00448 return ret1;
00449 }
00450 #endif
00451 }
00452
00453 #define _DBUS_MAX_SUN_PATH_LENGTH 99
00454
00482 int
00483 _dbus_connect_unix_socket (const char *path,
00484 dbus_bool_t abstract,
00485 DBusError *error)
00486 {
00487 int fd;
00488 size_t path_len;
00489 struct sockaddr_un addr;
00490
00491 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
00492
00493 _dbus_verbose ("connecting to unix socket %s abstract=%d\n",
00494 path, abstract);
00495
00496
00497 if (!_dbus_open_unix_socket (&fd, error))
00498 {
00499 _DBUS_ASSERT_ERROR_IS_SET(error);
00500 return -1;
00501 }
00502 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
00503
00504 _DBUS_ZERO (addr);
00505 addr.sun_family = AF_UNIX;
00506 path_len = strlen (path);
00507
00508 if (abstract)
00509 {
00510 #ifdef HAVE_ABSTRACT_SOCKETS
00511 addr.sun_path[0] = '\0';
00512 path_len++;
00513
00514 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
00515 {
00516 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
00517 "Abstract socket name too long\n");
00518 _dbus_close (fd, NULL);
00519 return -1;
00520 }
00521
00522 strncpy (&addr.sun_path[1], path, path_len);
00523
00524 #else
00525 dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
00526 "Operating system does not support abstract socket namespace\n");
00527 _dbus_close (fd, NULL);
00528 return -1;
00529 #endif
00530 }
00531 else
00532 {
00533 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
00534 {
00535 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
00536 "Socket name too long\n");
00537 _dbus_close (fd, NULL);
00538 return -1;
00539 }
00540
00541 strncpy (addr.sun_path, path, path_len);
00542 }
00543
00544 if (connect (fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
00545 {
00546 dbus_set_error (error,
00547 _dbus_error_from_errno (errno),
00548 "Failed to connect to socket %s: %s",
00549 path, _dbus_strerror (errno));
00550
00551 _dbus_close (fd, NULL);
00552 fd = -1;
00553
00554 return -1;
00555 }
00556
00557 if (!_dbus_set_fd_nonblocking (fd, error))
00558 {
00559 _DBUS_ASSERT_ERROR_IS_SET (error);
00560
00561 _dbus_close (fd, NULL);
00562 fd = -1;
00563
00564 return -1;
00565 }
00566
00567 return fd;
00568 }
00569
00579 static dbus_bool_t
00580 _dbus_set_local_creds (int fd, dbus_bool_t on)
00581 {
00582 dbus_bool_t retval = TRUE;
00583
00584 #if defined(HAVE_CMSGCRED)
00585
00586
00587
00588 #elif defined(LOCAL_CREDS)
00589 int val = on ? 1 : 0;
00590 if (setsockopt (fd, 0, LOCAL_CREDS, &val, sizeof (val)) < 0)
00591 {
00592 _dbus_verbose ("Unable to set LOCAL_CREDS socket option on fd %d\n", fd);
00593 retval = FALSE;
00594 }
00595 else
00596 _dbus_verbose ("LOCAL_CREDS %s for further messages on fd %d\n",
00597 on ? "enabled" : "disabled", fd);
00598 #endif
00599
00600 return retval;
00601 }
00602
00618 int
00619 _dbus_listen_unix_socket (const char *path,
00620 dbus_bool_t abstract,
00621 DBusError *error)
00622 {
00623 int listen_fd;
00624 struct sockaddr_un addr;
00625 size_t path_len;
00626
00627 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
00628
00629 _dbus_verbose ("listening on unix socket %s abstract=%d\n",
00630 path, abstract);
00631
00632 if (!_dbus_open_unix_socket (&listen_fd, error))
00633 {
00634 _DBUS_ASSERT_ERROR_IS_SET(error);
00635 return -1;
00636 }
00637 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
00638
00639 _DBUS_ZERO (addr);
00640 addr.sun_family = AF_UNIX;
00641 path_len = strlen (path);
00642
00643 if (abstract)
00644 {
00645 #ifdef HAVE_ABSTRACT_SOCKETS
00646
00647
00648
00649 addr.sun_path[0] = '\0';
00650 path_len++;
00651
00652 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
00653 {
00654 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
00655 "Abstract socket name too long\n");
00656 _dbus_close (listen_fd, NULL);
00657 return -1;
00658 }
00659
00660 strncpy (&addr.sun_path[1], path, path_len);
00661
00662 #else
00663 dbus_set_error (error, DBUS_ERROR_NOT_SUPPORTED,
00664 "Operating system does not support abstract socket namespace\n");
00665 _dbus_close (listen_fd, NULL);
00666 return -1;
00667 #endif
00668 }
00669 else
00670 {
00671
00672
00673
00674
00675
00676
00677
00678
00679
00680
00681 {
00682 struct stat sb;
00683
00684 if (stat (path, &sb) == 0 &&
00685 S_ISSOCK (sb.st_mode))
00686 unlink (path);
00687 }
00688
00689 if (path_len > _DBUS_MAX_SUN_PATH_LENGTH)
00690 {
00691 dbus_set_error (error, DBUS_ERROR_BAD_ADDRESS,
00692 "Abstract socket name too long\n");
00693 _dbus_close (listen_fd, NULL);
00694 return -1;
00695 }
00696
00697 strncpy (addr.sun_path, path, path_len);
00698 }
00699
00700 if (bind (listen_fd, (struct sockaddr*) &addr, _DBUS_STRUCT_OFFSET (struct sockaddr_un, sun_path) + path_len) < 0)
00701 {
00702 dbus_set_error (error, _dbus_error_from_errno (errno),
00703 "Failed to bind socket \"%s\": %s",
00704 path, _dbus_strerror (errno));
00705 _dbus_close (listen_fd, NULL);
00706 return -1;
00707 }
00708
00709 if (listen (listen_fd, 30 ) < 0)
00710 {
00711 dbus_set_error (error, _dbus_error_from_errno (errno),
00712 "Failed to listen on socket \"%s\": %s",
00713 path, _dbus_strerror (errno));
00714 _dbus_close (listen_fd, NULL);
00715 return -1;
00716 }
00717
00718 if (!_dbus_set_local_creds (listen_fd, TRUE))
00719 {
00720 dbus_set_error (error, _dbus_error_from_errno (errno),
00721 "Failed to enable LOCAL_CREDS on socket \"%s\": %s",
00722 path, _dbus_strerror (errno));
00723 close (listen_fd);
00724 return -1;
00725 }
00726
00727 if (!_dbus_set_fd_nonblocking (listen_fd, error))
00728 {
00729 _DBUS_ASSERT_ERROR_IS_SET (error);
00730 _dbus_close (listen_fd, NULL);
00731 return -1;
00732 }
00733
00734
00735
00736
00737 if (!abstract && chmod (path, 0777) < 0)
00738 _dbus_warn ("Could not set mode 0777 on socket %s\n",
00739 path);
00740
00741 return listen_fd;
00742 }
00743
00755 int
00756 _dbus_connect_tcp_socket (const char *host,
00757 const char *port,
00758 const char *family,
00759 DBusError *error)
00760 {
00761 int fd = -1, res;
00762 struct addrinfo hints;
00763 struct addrinfo *ai, *tmp;
00764
00765 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
00766
00767 if (!_dbus_open_tcp_socket (&fd, error))
00768 {
00769 _DBUS_ASSERT_ERROR_IS_SET(error);
00770 return -1;
00771 }
00772
00773 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
00774
00775 _DBUS_ZERO (hints);
00776
00777 if (!family)
00778 hints.ai_family = AF_UNSPEC;
00779 else if (!strcmp(family, "ipv4"))
00780 hints.ai_family = AF_INET;
00781 else if (!strcmp(family, "ipv6"))
00782 hints.ai_family = AF_INET6;
00783 else
00784 {
00785 dbus_set_error (error,
00786 _dbus_error_from_errno (errno),
00787 "Unknown address family %s", family);
00788 return -1;
00789 }
00790 hints.ai_protocol = IPPROTO_TCP;
00791 hints.ai_socktype = SOCK_STREAM;
00792 hints.ai_flags = AI_ADDRCONFIG;
00793
00794 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0)
00795 {
00796 dbus_set_error (error,
00797 _dbus_error_from_errno (errno),
00798 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
00799 host, port, gai_strerror(res), res);
00800 _dbus_close (fd, NULL);
00801 return -1;
00802 }
00803
00804 tmp = ai;
00805 while (tmp)
00806 {
00807 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
00808 {
00809 freeaddrinfo(ai);
00810 _DBUS_ASSERT_ERROR_IS_SET(error);
00811 return -1;
00812 }
00813 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
00814
00815 if (connect (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
00816 {
00817 _dbus_close(fd, NULL);
00818 fd = -1;
00819 tmp = tmp->ai_next;
00820 continue;
00821 }
00822
00823 break;
00824 }
00825 freeaddrinfo(ai);
00826
00827 if (fd == -1)
00828 {
00829 dbus_set_error (error,
00830 _dbus_error_from_errno (errno),
00831 "Failed to connect to socket \"%s:%s\" %s",
00832 host, port, _dbus_strerror(errno));
00833 return -1;
00834 }
00835
00836
00837 if (!_dbus_set_fd_nonblocking (fd, error))
00838 {
00839 _dbus_close (fd, NULL);
00840 fd = -1;
00841
00842 return -1;
00843 }
00844
00845 return fd;
00846 }
00847
00862 int
00863 _dbus_listen_tcp_socket (const char *host,
00864 const char *port,
00865 const char *family,
00866 DBusString *retport,
00867 int **fds_p,
00868 DBusError *error)
00869 {
00870 int nlisten_fd = 0, *listen_fd = NULL, res, i;
00871 struct addrinfo hints;
00872 struct addrinfo *ai, *tmp;
00873
00874 *fds_p = NULL;
00875 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
00876
00877 _DBUS_ZERO (hints);
00878
00879 if (!family)
00880 hints.ai_family = AF_UNSPEC;
00881 else if (!strcmp(family, "ipv4"))
00882 hints.ai_family = AF_INET;
00883 else if (!strcmp(family, "ipv6"))
00884 hints.ai_family = AF_INET6;
00885 else
00886 {
00887 dbus_set_error (error,
00888 _dbus_error_from_errno (errno),
00889 "Unknown address family %s", family);
00890 return -1;
00891 }
00892
00893 hints.ai_protocol = IPPROTO_TCP;
00894 hints.ai_socktype = SOCK_STREAM;
00895 hints.ai_flags = AI_ADDRCONFIG | AI_PASSIVE;
00896
00897 redo_lookup_with_port:
00898 if ((res = getaddrinfo(host, port, &hints, &ai)) != 0 || !ai)
00899 {
00900 dbus_set_error (error,
00901 _dbus_error_from_errno (errno),
00902 "Failed to lookup host/port: \"%s:%s\": %s (%d)",
00903 host ? host : "*", port, gai_strerror(res), res);
00904 return -1;
00905 }
00906
00907 tmp = ai;
00908 while (tmp)
00909 {
00910 int fd = -1, *newlisten_fd;
00911 if (!_dbus_open_socket (&fd, tmp->ai_family, SOCK_STREAM, 0, error))
00912 {
00913 _DBUS_ASSERT_ERROR_IS_SET(error);
00914 goto failed;
00915 }
00916 _DBUS_ASSERT_ERROR_IS_CLEAR(error);
00917
00918 if (bind (fd, (struct sockaddr*) tmp->ai_addr, tmp->ai_addrlen) < 0)
00919 {
00920 _dbus_close(fd, NULL);
00921 if (errno == EADDRINUSE)
00922 {
00923
00924
00925
00926 tmp = tmp->ai_next;
00927 continue;
00928 }
00929 dbus_set_error (error, _dbus_error_from_errno (errno),
00930 "Failed to bind socket \"%s:%s\": %s",
00931 host ? host : "*", port, _dbus_strerror (errno));
00932 goto failed;
00933 }
00934
00935 if (listen (fd, 30 ) < 0)
00936 {
00937 _dbus_close (fd, NULL);
00938 dbus_set_error (error, _dbus_error_from_errno (errno),
00939 "Failed to listen on socket \"%s:%s\": %s",
00940 host ? host : "*", port, _dbus_strerror (errno));
00941 goto failed;
00942 }
00943
00944 newlisten_fd = dbus_realloc(listen_fd, sizeof(int)*(nlisten_fd+1));
00945 if (!newlisten_fd)
00946 {
00947 _dbus_close (fd, NULL);
00948 dbus_set_error (error, _dbus_error_from_errno (errno),
00949 "Failed to allocate file handle array: %s",
00950 _dbus_strerror (errno));
00951 goto failed;
00952 }
00953 listen_fd = newlisten_fd;
00954 listen_fd[nlisten_fd] = fd;
00955 nlisten_fd++;
00956
00957 if (!_dbus_string_get_length(retport))
00958 {
00959
00960
00961
00962
00963 if (!port || !strcmp(port, "0"))
00964 {
00965 struct sockaddr_storage addr;
00966 socklen_t addrlen;
00967 char portbuf[50];
00968
00969 addrlen = sizeof(addr);
00970 getsockname(fd, (struct sockaddr*) &addr, &addrlen);
00971
00972 if ((res = getnameinfo((struct sockaddr*)&addr, addrlen, NULL, 0,
00973 portbuf, sizeof(portbuf),
00974 NI_NUMERICHOST)) != 0)
00975 {
00976 dbus_set_error (error, _dbus_error_from_errno (errno),
00977 "Failed to resolve port \"%s:%s\": %s (%s)",
00978 host ? host : "*", port, gai_strerror(res), res);
00979 goto failed;
00980 }
00981 if (!_dbus_string_append(retport, portbuf))
00982 {
00983 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
00984 goto failed;
00985 }
00986
00987
00988 port = _dbus_string_get_const_data(retport);
00989 freeaddrinfo(ai);
00990 goto redo_lookup_with_port;
00991 }
00992 else
00993 {
00994 if (!_dbus_string_append(retport, port))
00995 {
00996 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
00997 goto failed;
00998 }
00999 }
01000 }
01001
01002 tmp = tmp->ai_next;
01003 }
01004 freeaddrinfo(ai);
01005 ai = NULL;
01006
01007 if (!nlisten_fd)
01008 {
01009 errno = EADDRINUSE;
01010 dbus_set_error (error, _dbus_error_from_errno (errno),
01011 "Failed to bind socket \"%s:%s\": %s",
01012 host ? host : "*", port, _dbus_strerror (errno));
01013 return -1;
01014 }
01015
01016 for (i = 0 ; i < nlisten_fd ; i++)
01017 {
01018 if (!_dbus_set_fd_nonblocking (listen_fd[i], error))
01019 {
01020 goto failed;
01021 }
01022 }
01023
01024 *fds_p = listen_fd;
01025
01026 return nlisten_fd;
01027
01028 failed:
01029 if (ai)
01030 freeaddrinfo(ai);
01031 for (i = 0 ; i < nlisten_fd ; i++)
01032 _dbus_close(listen_fd[i], NULL);
01033 dbus_free(listen_fd);
01034 return -1;
01035 }
01036
01037 static dbus_bool_t
01038 write_credentials_byte (int server_fd,
01039 DBusError *error)
01040 {
01041 int bytes_written;
01042 char buf[1] = { '\0' };
01043 #if defined(HAVE_CMSGCRED)
01044 struct {
01045 struct cmsghdr hdr;
01046 struct cmsgcred cred;
01047 } cmsg;
01048 struct iovec iov;
01049 struct msghdr msg;
01050 iov.iov_base = buf;
01051 iov.iov_len = 1;
01052
01053 memset (&msg, 0, sizeof (msg));
01054 msg.msg_iov = &iov;
01055 msg.msg_iovlen = 1;
01056
01057 msg.msg_control = &cmsg;
01058 msg.msg_controllen = sizeof (cmsg);
01059 memset (&cmsg, 0, sizeof (cmsg));
01060 cmsg.hdr.cmsg_len = sizeof (cmsg);
01061 cmsg.hdr.cmsg_level = SOL_SOCKET;
01062 cmsg.hdr.cmsg_type = SCM_CREDS;
01063 #endif
01064
01065 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
01066
01067 again:
01068
01069 #if defined(HAVE_CMSGCRED)
01070 bytes_written = sendmsg (server_fd, &msg, 0);
01071 #else
01072 bytes_written = write (server_fd, buf, 1);
01073 #endif
01074
01075 if (bytes_written < 0 && errno == EINTR)
01076 goto again;
01077
01078 if (bytes_written < 0)
01079 {
01080 dbus_set_error (error, _dbus_error_from_errno (errno),
01081 "Failed to write credentials byte: %s",
01082 _dbus_strerror (errno));
01083 return FALSE;
01084 }
01085 else if (bytes_written == 0)
01086 {
01087 dbus_set_error (error, DBUS_ERROR_IO_ERROR,
01088 "wrote zero bytes writing credentials byte");
01089 return FALSE;
01090 }
01091 else
01092 {
01093 _dbus_assert (bytes_written == 1);
01094 _dbus_verbose ("wrote credentials byte\n");
01095 return TRUE;
01096 }
01097 }
01098
01120 dbus_bool_t
01121 _dbus_read_credentials_socket (int client_fd,
01122 DBusCredentials *credentials,
01123 DBusError *error)
01124 {
01125 struct msghdr msg;
01126 struct iovec iov;
01127 char buf;
01128 dbus_uid_t uid_read;
01129 dbus_pid_t pid_read;
01130 int bytes_read;
01131
01132 uid_read = DBUS_UID_UNSET;
01133 pid_read = DBUS_PID_UNSET;
01134
01135 #ifdef HAVE_CMSGCRED
01136 struct {
01137 struct cmsghdr hdr;
01138 struct cmsgcred cred;
01139 } cmsg;
01140
01141 #elif defined(LOCAL_CREDS)
01142 struct {
01143 struct cmsghdr hdr;
01144 struct sockcred cred;
01145 } cmsg;
01146 #endif
01147
01148 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
01149
01150
01151
01152
01153
01154 _dbus_assert (sizeof (pid_t) <= sizeof (dbus_pid_t));
01155 _dbus_assert (sizeof (uid_t) <= sizeof (dbus_uid_t));
01156 _dbus_assert (sizeof (gid_t) <= sizeof (dbus_gid_t));
01157
01158 _dbus_credentials_clear (credentials);
01159
01160
01161
01162
01163
01164
01165
01166 iov.iov_base = &buf;
01167 iov.iov_len = 1;
01168
01169 memset (&msg, 0, sizeof (msg));
01170 msg.msg_iov = &iov;
01171 msg.msg_iovlen = 1;
01172
01173 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
01174 memset (&cmsg, 0, sizeof (cmsg));
01175 msg.msg_control = &cmsg;
01176 msg.msg_controllen = sizeof (cmsg);
01177 #endif
01178
01179 again:
01180 bytes_read = recvmsg (client_fd, &msg, 0);
01181
01182 if (bytes_read < 0)
01183 {
01184 if (errno == EINTR)
01185 goto again;
01186
01187
01188
01189
01190
01191
01192 dbus_set_error (error, _dbus_error_from_errno (errno),
01193 "Failed to read credentials byte: %s",
01194 _dbus_strerror (errno));
01195 return FALSE;
01196 }
01197 else if (bytes_read == 0)
01198 {
01199
01200
01201
01202 dbus_set_error (error, DBUS_ERROR_FAILED,
01203 "Failed to read credentials byte (zero-length read)");
01204 return FALSE;
01205 }
01206 else if (buf != '\0')
01207 {
01208 dbus_set_error (error, DBUS_ERROR_FAILED,
01209 "Credentials byte was not nul");
01210 return FALSE;
01211 }
01212
01213 #if defined(HAVE_CMSGCRED) || defined(LOCAL_CREDS)
01214 if (cmsg.hdr.cmsg_len < sizeof (cmsg) || cmsg.hdr.cmsg_type != SCM_CREDS)
01215 {
01216 dbus_set_error (error, DBUS_ERROR_FAILED,
01217 "Message from recvmsg() was not SCM_CREDS");
01218 return FALSE;
01219 }
01220 #endif
01221
01222 _dbus_verbose ("read credentials byte\n");
01223
01224 {
01225 #ifdef SO_PEERCRED
01226 struct ucred cr;
01227 int cr_len = sizeof (cr);
01228
01229 if (getsockopt (client_fd, SOL_SOCKET, SO_PEERCRED, &cr, &cr_len) == 0 &&
01230 cr_len == sizeof (cr))
01231 {
01232 pid_read = cr.pid;
01233 uid_read = cr.uid;
01234 }
01235 else
01236 {
01237 _dbus_verbose ("Failed to getsockopt() credentials, returned len %d/%d: %s\n",
01238 cr_len, (int) sizeof (cr), _dbus_strerror (errno));
01239 }
01240 #elif defined(HAVE_CMSGCRED)
01241 pid_read = cmsg.cred.cmcred_pid;
01242 uid_read = cmsg.cred.cmcred_euid;
01243 #elif defined(LOCAL_CREDS)
01244 pid_read = DBUS_PID_UNSET;
01245 uid_read = cmsg.cred.sc_uid;
01246
01247
01248 _dbus_set_local_creds (client_fd, FALSE);
01249 #elif defined(HAVE_GETPEEREID)
01250 uid_t euid;
01251 gid_t egid;
01252 if (getpeereid (client_fd, &euid, &egid) == 0)
01253 {
01254 uid_read = euid;
01255 }
01256 else
01257 {
01258 _dbus_verbose ("Failed to getpeereid() credentials: %s\n", _dbus_strerror (errno));
01259 }
01260 #elif defined(HAVE_GETPEERUCRED)
01261 ucred_t * ucred = NULL;
01262 if (getpeerucred (client_fd, &ucred) == 0)
01263 {
01264 pid_read = ucred_getpid (ucred);
01265 uid_read = ucred_geteuid (ucred);
01266 #ifdef HAVE_ADT
01267
01268 adt_session_data_t *adth = NULL;
01269 adt_export_data_t *data = NULL;
01270 size_t size = 0;
01271 if (adt_start_session (&adth, NULL, 0) || (adth == NULL))
01272 {
01273 _dbus_verbose ("Failed to adt_start_session(): %s\n", _dbus_strerror (errno));
01274 }
01275 else
01276 {
01277 if (adt_set_from_ucred (adth, ucred, ADT_NEW))
01278 {
01279 _dbus_verbose ("Failed to adt_set_from_ucred(): %s\n", _dbus_strerror (errno));
01280 }
01281 else
01282 {
01283 size = adt_export_session_data (adth, &data);
01284 if (size <= 0)
01285 {
01286 _dbus_verbose ("Failed to adt_export_session_data(): %s\n", _dbus_strerror (errno));
01287 }
01288 else
01289 {
01290 _dbus_credentials_add_adt_audit_data (credentials, data, size);
01291 free (data);
01292 }
01293 }
01294 (void) adt_end_session (adth);
01295 }
01296 #endif
01297 }
01298 else
01299 {
01300 _dbus_verbose ("Failed to getpeerucred() credentials: %s\n", _dbus_strerror (errno));
01301 }
01302 if (ucred != NULL)
01303 ucred_free (ucred);
01304 #else
01305 _dbus_verbose ("Socket credentials not supported on this OS\n");
01306 #endif
01307 }
01308
01309 _dbus_verbose ("Credentials:"
01310 " pid "DBUS_PID_FORMAT
01311 " uid "DBUS_UID_FORMAT
01312 "\n",
01313 pid_read,
01314 uid_read);
01315
01316 if (pid_read != DBUS_PID_UNSET)
01317 {
01318 if (!_dbus_credentials_add_unix_pid (credentials, pid_read))
01319 {
01320 _DBUS_SET_OOM (error);
01321 return FALSE;
01322 }
01323 }
01324
01325 if (uid_read != DBUS_UID_UNSET)
01326 {
01327 if (!_dbus_credentials_add_unix_uid (credentials, uid_read))
01328 {
01329 _DBUS_SET_OOM (error);
01330 return FALSE;
01331 }
01332 }
01333
01334 return TRUE;
01335 }
01336
01354 dbus_bool_t
01355 _dbus_send_credentials_socket (int server_fd,
01356 DBusError *error)
01357 {
01358 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
01359
01360 if (write_credentials_byte (server_fd, error))
01361 return TRUE;
01362 else
01363 return FALSE;
01364 }
01365
01373 int
01374 _dbus_accept (int listen_fd)
01375 {
01376 int client_fd;
01377 struct sockaddr addr;
01378 socklen_t addrlen;
01379
01380 addrlen = sizeof (addr);
01381
01382 retry:
01383 client_fd = accept (listen_fd, &addr, &addrlen);
01384
01385 if (client_fd < 0)
01386 {
01387 if (errno == EINTR)
01388 goto retry;
01389 }
01390
01391 _dbus_verbose ("client fd %d accepted\n", client_fd);
01392
01393 return client_fd;
01394 }
01395
01404 dbus_bool_t
01405 _dbus_check_dir_is_private_to_user (DBusString *dir, DBusError *error)
01406 {
01407 const char *directory;
01408 struct stat sb;
01409
01410 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
01411
01412 directory = _dbus_string_get_const_data (dir);
01413
01414 if (stat (directory, &sb) < 0)
01415 {
01416 dbus_set_error (error, _dbus_error_from_errno (errno),
01417 "%s", _dbus_strerror (errno));
01418
01419 return FALSE;
01420 }
01421
01422 if ((S_IROTH & sb.st_mode) || (S_IWOTH & sb.st_mode) ||
01423 (S_IRGRP & sb.st_mode) || (S_IWGRP & sb.st_mode))
01424 {
01425 dbus_set_error (error, DBUS_ERROR_FAILED,
01426 "%s directory is not private to the user", directory);
01427 return FALSE;
01428 }
01429
01430 return TRUE;
01431 }
01432
01433 static dbus_bool_t
01434 fill_user_info_from_passwd (struct passwd *p,
01435 DBusUserInfo *info,
01436 DBusError *error)
01437 {
01438 _dbus_assert (p->pw_name != NULL);
01439 _dbus_assert (p->pw_dir != NULL);
01440
01441 info->uid = p->pw_uid;
01442 info->primary_gid = p->pw_gid;
01443 info->username = _dbus_strdup (p->pw_name);
01444 info->homedir = _dbus_strdup (p->pw_dir);
01445
01446 if (info->username == NULL ||
01447 info->homedir == NULL)
01448 {
01449 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
01450 return FALSE;
01451 }
01452
01453 return TRUE;
01454 }
01455
01456 static dbus_bool_t
01457 fill_user_info (DBusUserInfo *info,
01458 dbus_uid_t uid,
01459 const DBusString *username,
01460 DBusError *error)
01461 {
01462 const char *username_c;
01463
01464
01465 _dbus_assert (username != NULL || uid != DBUS_UID_UNSET);
01466 _dbus_assert (username == NULL || uid == DBUS_UID_UNSET);
01467
01468 info->uid = DBUS_UID_UNSET;
01469 info->primary_gid = DBUS_GID_UNSET;
01470 info->group_ids = NULL;
01471 info->n_group_ids = 0;
01472 info->username = NULL;
01473 info->homedir = NULL;
01474
01475 if (username != NULL)
01476 username_c = _dbus_string_get_const_data (username);
01477 else
01478 username_c = NULL;
01479
01480
01481
01482
01483
01484
01485 #if defined (HAVE_POSIX_GETPWNAM_R) || defined (HAVE_NONPOSIX_GETPWNAM_R)
01486 {
01487 struct passwd *p;
01488 int result;
01489 size_t buflen;
01490 char *buf;
01491 struct passwd p_str;
01492
01493
01494 buflen = sysconf (_SC_GETPW_R_SIZE_MAX);
01495
01496 if (buflen <= 0)
01497 buflen = 1024;
01498
01499 result = -1;
01500 while (1)
01501 {
01502 buf = dbus_malloc (buflen);
01503 if (buf == NULL)
01504 {
01505 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
01506 return FALSE;
01507 }
01508
01509 p = NULL;
01510 #ifdef HAVE_POSIX_GETPWNAM_R
01511 if (uid != DBUS_UID_UNSET)
01512 result = getpwuid_r (uid, &p_str, buf, buflen,
01513 &p);
01514 else
01515 result = getpwnam_r (username_c, &p_str, buf, buflen,
01516 &p);
01517 #else
01518 if (uid != DBUS_UID_UNSET)
01519 p = getpwuid_r (uid, &p_str, buf, buflen);
01520 else
01521 p = getpwnam_r (username_c, &p_str, buf, buflen);
01522 result = 0;
01523 #endif
01524
01525 if (result == ERANGE && buflen < 512 * 1024)
01526 {
01527 dbus_free (buf);
01528 buflen *= 2;
01529 }
01530 else
01531 {
01532 break;
01533 }
01534 }
01535 if (result == 0 && p == &p_str)
01536 {
01537 if (!fill_user_info_from_passwd (p, info, error))
01538 {
01539 dbus_free (buf);
01540 return FALSE;
01541 }
01542 dbus_free (buf);
01543 }
01544 else
01545 {
01546 dbus_set_error (error, _dbus_error_from_errno (errno),
01547 "User \"%s\" unknown or no memory to allocate password entry\n",
01548 username_c ? username_c : "???");
01549 _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
01550 dbus_free (buf);
01551 return FALSE;
01552 }
01553 }
01554 #else
01555 {
01556
01557 struct passwd *p;
01558
01559 if (uid != DBUS_UID_UNSET)
01560 p = getpwuid (uid);
01561 else
01562 p = getpwnam (username_c);
01563
01564 if (p != NULL)
01565 {
01566 if (!fill_user_info_from_passwd (p, info, error))
01567 {
01568 return FALSE;
01569 }
01570 }
01571 else
01572 {
01573 dbus_set_error (error, _dbus_error_from_errno (errno),
01574 "User \"%s\" unknown or no memory to allocate password entry\n",
01575 username_c ? username_c : "???");
01576 _dbus_verbose ("User %s unknown\n", username_c ? username_c : "???");
01577 return FALSE;
01578 }
01579 }
01580 #endif
01581
01582
01583 username_c = info->username;
01584
01585 #ifdef HAVE_GETGROUPLIST
01586 {
01587 gid_t *buf;
01588 int buf_count;
01589 int i;
01590
01591 buf_count = 17;
01592 buf = dbus_new (gid_t, buf_count);
01593 if (buf == NULL)
01594 {
01595 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
01596 goto failed;
01597 }
01598
01599 if (getgrouplist (username_c,
01600 info->primary_gid,
01601 buf, &buf_count) < 0)
01602 {
01603 gid_t *new = dbus_realloc (buf, buf_count * sizeof (buf[0]));
01604 if (new == NULL)
01605 {
01606 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
01607 dbus_free (buf);
01608 goto failed;
01609 }
01610
01611 buf = new;
01612
01613 errno = 0;
01614 if (getgrouplist (username_c, info->primary_gid, buf, &buf_count) < 0)
01615 {
01616 dbus_set_error (error,
01617 _dbus_error_from_errno (errno),
01618 "Failed to get groups for username \"%s\" primary GID "
01619 DBUS_GID_FORMAT ": %s\n",
01620 username_c, info->primary_gid,
01621 _dbus_strerror (errno));
01622 dbus_free (buf);
01623 goto failed;
01624 }
01625 }
01626
01627 info->group_ids = dbus_new (dbus_gid_t, buf_count);
01628 if (info->group_ids == NULL)
01629 {
01630 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
01631 dbus_free (buf);
01632 goto failed;
01633 }
01634
01635 for (i = 0; i < buf_count; ++i)
01636 info->group_ids[i] = buf[i];
01637
01638 info->n_group_ids = buf_count;
01639
01640 dbus_free (buf);
01641 }
01642 #else
01643 {
01644
01645 info->group_ids = dbus_new (dbus_gid_t, 1);
01646 if (info->group_ids == NULL)
01647 {
01648 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
01649 goto failed;
01650 }
01651
01652 info->n_group_ids = 1;
01653
01654 (info->group_ids)[0] = info->primary_gid;
01655 }
01656 #endif
01657
01658 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
01659
01660 return TRUE;
01661
01662 failed:
01663 _DBUS_ASSERT_ERROR_IS_SET (error);
01664 return FALSE;
01665 }
01666
01675 dbus_bool_t
01676 _dbus_user_info_fill (DBusUserInfo *info,
01677 const DBusString *username,
01678 DBusError *error)
01679 {
01680 return fill_user_info (info, DBUS_UID_UNSET,
01681 username, error);
01682 }
01683
01692 dbus_bool_t
01693 _dbus_user_info_fill_uid (DBusUserInfo *info,
01694 dbus_uid_t uid,
01695 DBusError *error)
01696 {
01697 return fill_user_info (info, uid,
01698 NULL, error);
01699 }
01700
01708 dbus_bool_t
01709 _dbus_credentials_add_from_current_process (DBusCredentials *credentials)
01710 {
01711
01712
01713
01714
01715 _dbus_assert (sizeof (pid_t) <= sizeof (dbus_pid_t));
01716 _dbus_assert (sizeof (uid_t) <= sizeof (dbus_uid_t));
01717 _dbus_assert (sizeof (gid_t) <= sizeof (dbus_gid_t));
01718
01719 if (!_dbus_credentials_add_unix_pid(credentials, _dbus_getpid()))
01720 return FALSE;
01721 if (!_dbus_credentials_add_unix_uid(credentials, _dbus_geteuid()))
01722 return FALSE;
01723
01724 return TRUE;
01725 }
01726
01738 dbus_bool_t
01739 _dbus_append_user_from_current_process (DBusString *str)
01740 {
01741 return _dbus_string_append_uint (str,
01742 _dbus_geteuid ());
01743 }
01744
01749 dbus_pid_t
01750 _dbus_getpid (void)
01751 {
01752 return getpid ();
01753 }
01754
01758 dbus_uid_t
01759 _dbus_getuid (void)
01760 {
01761 return getuid ();
01762 }
01763
01767 dbus_uid_t
01768 _dbus_geteuid (void)
01769 {
01770 return geteuid ();
01771 }
01772
01779 unsigned long
01780 _dbus_pid_for_log (void)
01781 {
01782 return getpid ();
01783 }
01784
01792 dbus_bool_t
01793 _dbus_parse_uid (const DBusString *uid_str,
01794 dbus_uid_t *uid)
01795 {
01796 int end;
01797 long val;
01798
01799 if (_dbus_string_get_length (uid_str) == 0)
01800 {
01801 _dbus_verbose ("UID string was zero length\n");
01802 return FALSE;
01803 }
01804
01805 val = -1;
01806 end = 0;
01807 if (!_dbus_string_parse_int (uid_str, 0, &val,
01808 &end))
01809 {
01810 _dbus_verbose ("could not parse string as a UID\n");
01811 return FALSE;
01812 }
01813
01814 if (end != _dbus_string_get_length (uid_str))
01815 {
01816 _dbus_verbose ("string contained trailing stuff after UID\n");
01817 return FALSE;
01818 }
01819
01820 *uid = val;
01821
01822 return TRUE;
01823 }
01824
01825
01826 _DBUS_DEFINE_GLOBAL_LOCK (atomic);
01827
01828 #if DBUS_USE_ATOMIC_INT_486_COND
01829
01830
01831 static inline dbus_int32_t
01832 atomic_exchange_and_add (DBusAtomic *atomic,
01833 volatile dbus_int32_t val)
01834 {
01835 register dbus_int32_t result;
01836
01837 __asm__ __volatile__ ("lock; xaddl %0,%1"
01838 : "=r" (result), "=m" (atomic->value)
01839 : "0" (val), "m" (atomic->value));
01840 return result;
01841 }
01842 #endif
01843
01852 dbus_int32_t
01853 _dbus_atomic_inc (DBusAtomic *atomic)
01854 {
01855 #if DBUS_USE_ATOMIC_INT_486_COND
01856 return atomic_exchange_and_add (atomic, 1);
01857 #else
01858 dbus_int32_t res;
01859 _DBUS_LOCK (atomic);
01860 res = atomic->value;
01861 atomic->value += 1;
01862 _DBUS_UNLOCK (atomic);
01863 return res;
01864 #endif
01865 }
01866
01875 dbus_int32_t
01876 _dbus_atomic_dec (DBusAtomic *atomic)
01877 {
01878 #if DBUS_USE_ATOMIC_INT_486_COND
01879 return atomic_exchange_and_add (atomic, -1);
01880 #else
01881 dbus_int32_t res;
01882
01883 _DBUS_LOCK (atomic);
01884 res = atomic->value;
01885 atomic->value -= 1;
01886 _DBUS_UNLOCK (atomic);
01887 return res;
01888 #endif
01889 }
01890
01891 #ifdef DBUS_BUILD_TESTS
01892
01895 dbus_gid_t
01896 _dbus_getgid (void)
01897 {
01898 return getgid ();
01899 }
01900 #endif
01901
01910 int
01911 _dbus_poll (DBusPollFD *fds,
01912 int n_fds,
01913 int timeout_milliseconds)
01914 {
01915 #if defined(HAVE_POLL) && !defined(BROKEN_POLL)
01916
01917
01918
01919
01920 if (_DBUS_POLLIN == POLLIN &&
01921 _DBUS_POLLPRI == POLLPRI &&
01922 _DBUS_POLLOUT == POLLOUT &&
01923 _DBUS_POLLERR == POLLERR &&
01924 _DBUS_POLLHUP == POLLHUP &&
01925 _DBUS_POLLNVAL == POLLNVAL &&
01926 sizeof (DBusPollFD) == sizeof (struct pollfd) &&
01927 _DBUS_STRUCT_OFFSET (DBusPollFD, fd) ==
01928 _DBUS_STRUCT_OFFSET (struct pollfd, fd) &&
01929 _DBUS_STRUCT_OFFSET (DBusPollFD, events) ==
01930 _DBUS_STRUCT_OFFSET (struct pollfd, events) &&
01931 _DBUS_STRUCT_OFFSET (DBusPollFD, revents) ==
01932 _DBUS_STRUCT_OFFSET (struct pollfd, revents))
01933 {
01934 return poll ((struct pollfd*) fds,
01935 n_fds,
01936 timeout_milliseconds);
01937 }
01938 else
01939 {
01940
01941
01942
01943 _dbus_warn ("didn't implement poll() properly for this system yet\n");
01944 return -1;
01945 }
01946 #else
01947
01948 fd_set read_set, write_set, err_set;
01949 int max_fd = 0;
01950 int i;
01951 struct timeval tv;
01952 int ready;
01953
01954 FD_ZERO (&read_set);
01955 FD_ZERO (&write_set);
01956 FD_ZERO (&err_set);
01957
01958 for (i = 0; i < n_fds; i++)
01959 {
01960 DBusPollFD *fdp = &fds[i];
01961
01962 if (fdp->events & _DBUS_POLLIN)
01963 FD_SET (fdp->fd, &read_set);
01964
01965 if (fdp->events & _DBUS_POLLOUT)
01966 FD_SET (fdp->fd, &write_set);
01967
01968 FD_SET (fdp->fd, &err_set);
01969
01970 max_fd = MAX (max_fd, fdp->fd);
01971 }
01972
01973 tv.tv_sec = timeout_milliseconds / 1000;
01974 tv.tv_usec = (timeout_milliseconds % 1000) * 1000;
01975
01976 ready = select (max_fd + 1, &read_set, &write_set, &err_set,
01977 timeout_milliseconds < 0 ? NULL : &tv);
01978
01979 if (ready > 0)
01980 {
01981 for (i = 0; i < n_fds; i++)
01982 {
01983 DBusPollFD *fdp = &fds[i];
01984
01985 fdp->revents = 0;
01986
01987 if (FD_ISSET (fdp->fd, &read_set))
01988 fdp->revents |= _DBUS_POLLIN;
01989
01990 if (FD_ISSET (fdp->fd, &write_set))
01991 fdp->revents |= _DBUS_POLLOUT;
01992
01993 if (FD_ISSET (fdp->fd, &err_set))
01994 fdp->revents |= _DBUS_POLLERR;
01995 }
01996 }
01997
01998 return ready;
01999 #endif
02000 }
02001
02008 void
02009 _dbus_get_current_time (long *tv_sec,
02010 long *tv_usec)
02011 {
02012 struct timeval t;
02013
02014 gettimeofday (&t, NULL);
02015
02016 if (tv_sec)
02017 *tv_sec = t.tv_sec;
02018 if (tv_usec)
02019 *tv_usec = t.tv_usec;
02020 }
02021
02032 dbus_bool_t
02033 _dbus_file_get_contents (DBusString *str,
02034 const DBusString *filename,
02035 DBusError *error)
02036 {
02037 int fd;
02038 struct stat sb;
02039 int orig_len;
02040 int total;
02041 const char *filename_c;
02042
02043 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02044
02045 filename_c = _dbus_string_get_const_data (filename);
02046
02047
02048 fd = open (filename_c, O_RDONLY | O_BINARY);
02049 if (fd < 0)
02050 {
02051 dbus_set_error (error, _dbus_error_from_errno (errno),
02052 "Failed to open \"%s\": %s",
02053 filename_c,
02054 _dbus_strerror (errno));
02055 return FALSE;
02056 }
02057
02058 _dbus_verbose ("file fd %d opened\n", fd);
02059
02060 if (fstat (fd, &sb) < 0)
02061 {
02062 dbus_set_error (error, _dbus_error_from_errno (errno),
02063 "Failed to stat \"%s\": %s",
02064 filename_c,
02065 _dbus_strerror (errno));
02066
02067 _dbus_verbose ("fstat() failed: %s",
02068 _dbus_strerror (errno));
02069
02070 _dbus_close (fd, NULL);
02071
02072 return FALSE;
02073 }
02074
02075 if (sb.st_size > _DBUS_ONE_MEGABYTE)
02076 {
02077 dbus_set_error (error, DBUS_ERROR_FAILED,
02078 "File size %lu of \"%s\" is too large.",
02079 (unsigned long) sb.st_size, filename_c);
02080 _dbus_close (fd, NULL);
02081 return FALSE;
02082 }
02083
02084 total = 0;
02085 orig_len = _dbus_string_get_length (str);
02086 if (sb.st_size > 0 && S_ISREG (sb.st_mode))
02087 {
02088 int bytes_read;
02089
02090 while (total < (int) sb.st_size)
02091 {
02092 bytes_read = _dbus_read (fd, str,
02093 sb.st_size - total);
02094 if (bytes_read <= 0)
02095 {
02096 dbus_set_error (error, _dbus_error_from_errno (errno),
02097 "Error reading \"%s\": %s",
02098 filename_c,
02099 _dbus_strerror (errno));
02100
02101 _dbus_verbose ("read() failed: %s",
02102 _dbus_strerror (errno));
02103
02104 _dbus_close (fd, NULL);
02105 _dbus_string_set_length (str, orig_len);
02106 return FALSE;
02107 }
02108 else
02109 total += bytes_read;
02110 }
02111
02112 _dbus_close (fd, NULL);
02113 return TRUE;
02114 }
02115 else if (sb.st_size != 0)
02116 {
02117 _dbus_verbose ("Can only open regular files at the moment.\n");
02118 dbus_set_error (error, DBUS_ERROR_FAILED,
02119 "\"%s\" is not a regular file",
02120 filename_c);
02121 _dbus_close (fd, NULL);
02122 return FALSE;
02123 }
02124 else
02125 {
02126 _dbus_close (fd, NULL);
02127 return TRUE;
02128 }
02129 }
02130
02140 dbus_bool_t
02141 _dbus_string_save_to_file (const DBusString *str,
02142 const DBusString *filename,
02143 DBusError *error)
02144 {
02145 int fd;
02146 int bytes_to_write;
02147 const char *filename_c;
02148 DBusString tmp_filename;
02149 const char *tmp_filename_c;
02150 int total;
02151 dbus_bool_t need_unlink;
02152 dbus_bool_t retval;
02153
02154 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02155
02156 fd = -1;
02157 retval = FALSE;
02158 need_unlink = FALSE;
02159
02160 if (!_dbus_string_init (&tmp_filename))
02161 {
02162 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
02163 return FALSE;
02164 }
02165
02166 if (!_dbus_string_copy (filename, 0, &tmp_filename, 0))
02167 {
02168 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
02169 _dbus_string_free (&tmp_filename);
02170 return FALSE;
02171 }
02172
02173 if (!_dbus_string_append (&tmp_filename, "."))
02174 {
02175 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
02176 _dbus_string_free (&tmp_filename);
02177 return FALSE;
02178 }
02179
02180 #define N_TMP_FILENAME_RANDOM_BYTES 8
02181 if (!_dbus_generate_random_ascii (&tmp_filename, N_TMP_FILENAME_RANDOM_BYTES))
02182 {
02183 dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
02184 _dbus_string_free (&tmp_filename);
02185 return FALSE;
02186 }
02187
02188 filename_c = _dbus_string_get_const_data (filename);
02189 tmp_filename_c = _dbus_string_get_const_data (&tmp_filename);
02190
02191 fd = open (tmp_filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
02192 0600);
02193 if (fd < 0)
02194 {
02195 dbus_set_error (error, _dbus_error_from_errno (errno),
02196 "Could not create %s: %s", tmp_filename_c,
02197 _dbus_strerror (errno));
02198 goto out;
02199 }
02200
02201 _dbus_verbose ("tmp file fd %d opened\n", fd);
02202
02203 need_unlink = TRUE;
02204
02205 total = 0;
02206 bytes_to_write = _dbus_string_get_length (str);
02207
02208 while (total < bytes_to_write)
02209 {
02210 int bytes_written;
02211
02212 bytes_written = _dbus_write (fd, str, total,
02213 bytes_to_write - total);
02214
02215 if (bytes_written <= 0)
02216 {
02217 dbus_set_error (error, _dbus_error_from_errno (errno),
02218 "Could not write to %s: %s", tmp_filename_c,
02219 _dbus_strerror (errno));
02220
02221 goto out;
02222 }
02223
02224 total += bytes_written;
02225 }
02226
02227 if (!_dbus_close (fd, NULL))
02228 {
02229 dbus_set_error (error, _dbus_error_from_errno (errno),
02230 "Could not close file %s: %s",
02231 tmp_filename_c, _dbus_strerror (errno));
02232
02233 goto out;
02234 }
02235
02236 fd = -1;
02237
02238 if (rename (tmp_filename_c, filename_c) < 0)
02239 {
02240 dbus_set_error (error, _dbus_error_from_errno (errno),
02241 "Could not rename %s to %s: %s",
02242 tmp_filename_c, filename_c,
02243 _dbus_strerror (errno));
02244
02245 goto out;
02246 }
02247
02248 need_unlink = FALSE;
02249
02250 retval = TRUE;
02251
02252 out:
02253
02254
02255
02256
02257 if (fd >= 0)
02258 _dbus_close (fd, NULL);
02259
02260 if (need_unlink && unlink (tmp_filename_c) < 0)
02261 _dbus_verbose ("Failed to unlink temp file %s: %s\n",
02262 tmp_filename_c, _dbus_strerror (errno));
02263
02264 _dbus_string_free (&tmp_filename);
02265
02266 if (!retval)
02267 _DBUS_ASSERT_ERROR_IS_SET (error);
02268
02269 return retval;
02270 }
02271
02278 dbus_bool_t
02279 _dbus_make_file_world_readable(const DBusString *filename,
02280 DBusError *error)
02281 {
02282 const char *filename_c;
02283
02284 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02285
02286 filename_c = _dbus_string_get_const_data (filename);
02287 if (chmod (filename_c, 0644) == -1)
02288 {
02289 dbus_set_error (error,
02290 DBUS_ERROR_FAILED,
02291 "Could not change permissions of file %s: %s\n",
02292 filename_c,
02293 _dbus_strerror (errno));
02294 return FALSE;
02295 }
02296 return TRUE;
02297 }
02298
02305 dbus_bool_t
02306 _dbus_create_file_exclusively (const DBusString *filename,
02307 DBusError *error)
02308 {
02309 int fd;
02310 const char *filename_c;
02311
02312 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02313
02314 filename_c = _dbus_string_get_const_data (filename);
02315
02316 fd = open (filename_c, O_WRONLY | O_BINARY | O_EXCL | O_CREAT,
02317 0600);
02318 if (fd < 0)
02319 {
02320 dbus_set_error (error,
02321 DBUS_ERROR_FAILED,
02322 "Could not create file %s: %s\n",
02323 filename_c,
02324 _dbus_strerror (errno));
02325 return FALSE;
02326 }
02327
02328 _dbus_verbose ("exclusive file fd %d opened\n", fd);
02329
02330 if (!_dbus_close (fd, NULL))
02331 {
02332 dbus_set_error (error,
02333 DBUS_ERROR_FAILED,
02334 "Could not close file %s: %s\n",
02335 filename_c,
02336 _dbus_strerror (errno));
02337 return FALSE;
02338 }
02339
02340 return TRUE;
02341 }
02342
02351 dbus_bool_t
02352 _dbus_delete_file (const DBusString *filename,
02353 DBusError *error)
02354 {
02355 const char *filename_c;
02356
02357 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02358
02359 filename_c = _dbus_string_get_const_data (filename);
02360
02361 if (unlink (filename_c) < 0)
02362 {
02363 dbus_set_error (error, DBUS_ERROR_FAILED,
02364 "Failed to delete file %s: %s\n",
02365 filename_c, _dbus_strerror (errno));
02366 return FALSE;
02367 }
02368 else
02369 return TRUE;
02370 }
02371
02380 dbus_bool_t
02381 _dbus_create_directory (const DBusString *filename,
02382 DBusError *error)
02383 {
02384 const char *filename_c;
02385
02386 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02387
02388 filename_c = _dbus_string_get_const_data (filename);
02389
02390 if (mkdir (filename_c, 0700) < 0)
02391 {
02392 if (errno == EEXIST)
02393 return TRUE;
02394
02395 dbus_set_error (error, DBUS_ERROR_FAILED,
02396 "Failed to create directory %s: %s\n",
02397 filename_c, _dbus_strerror (errno));
02398 return FALSE;
02399 }
02400 else
02401 return TRUE;
02402 }
02403
02414 dbus_bool_t
02415 _dbus_concat_dir_and_file (DBusString *dir,
02416 const DBusString *next_component)
02417 {
02418 dbus_bool_t dir_ends_in_slash;
02419 dbus_bool_t file_starts_with_slash;
02420
02421 if (_dbus_string_get_length (dir) == 0 ||
02422 _dbus_string_get_length (next_component) == 0)
02423 return TRUE;
02424
02425 dir_ends_in_slash = '/' == _dbus_string_get_byte (dir,
02426 _dbus_string_get_length (dir) - 1);
02427
02428 file_starts_with_slash = '/' == _dbus_string_get_byte (next_component, 0);
02429
02430 if (dir_ends_in_slash && file_starts_with_slash)
02431 {
02432 _dbus_string_shorten (dir, 1);
02433 }
02434 else if (!(dir_ends_in_slash || file_starts_with_slash))
02435 {
02436 if (!_dbus_string_append_byte (dir, '/'))
02437 return FALSE;
02438 }
02439
02440 return _dbus_string_copy (next_component, 0, dir,
02441 _dbus_string_get_length (dir));
02442 }
02443
02445 #define NANOSECONDS_PER_SECOND 1000000000
02446
02447 #define MICROSECONDS_PER_SECOND 1000000
02448
02449 #define MILLISECONDS_PER_SECOND 1000
02450
02451 #define NANOSECONDS_PER_MILLISECOND 1000000
02452
02453 #define MICROSECONDS_PER_MILLISECOND 1000
02454
02459 void
02460 _dbus_sleep_milliseconds (int milliseconds)
02461 {
02462 #ifdef HAVE_NANOSLEEP
02463 struct timespec req;
02464 struct timespec rem;
02465
02466 req.tv_sec = milliseconds / MILLISECONDS_PER_SECOND;
02467 req.tv_nsec = (milliseconds % MILLISECONDS_PER_SECOND) * NANOSECONDS_PER_MILLISECOND;
02468 rem.tv_sec = 0;
02469 rem.tv_nsec = 0;
02470
02471 while (nanosleep (&req, &rem) < 0 && errno == EINTR)
02472 req = rem;
02473 #elif defined (HAVE_USLEEP)
02474 usleep (milliseconds * MICROSECONDS_PER_MILLISECOND);
02475 #else
02476 sleep (MAX (milliseconds / 1000, 1));
02477 #endif
02478 }
02479
02480 static dbus_bool_t
02481 _dbus_generate_pseudorandom_bytes (DBusString *str,
02482 int n_bytes)
02483 {
02484 int old_len;
02485 char *p;
02486
02487 old_len = _dbus_string_get_length (str);
02488
02489 if (!_dbus_string_lengthen (str, n_bytes))
02490 return FALSE;
02491
02492 p = _dbus_string_get_data_len (str, old_len, n_bytes);
02493
02494 _dbus_generate_pseudorandom_bytes_buffer (p, n_bytes);
02495
02496 return TRUE;
02497 }
02498
02507 dbus_bool_t
02508 _dbus_generate_random_bytes (DBusString *str,
02509 int n_bytes)
02510 {
02511 int old_len;
02512 int fd;
02513
02514
02515
02516
02517
02518
02519
02520 old_len = _dbus_string_get_length (str);
02521 fd = -1;
02522
02523
02524 fd = open ("/dev/urandom", O_RDONLY);
02525 if (fd < 0)
02526 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
02527
02528 _dbus_verbose ("/dev/urandom fd %d opened\n", fd);
02529
02530 if (_dbus_read (fd, str, n_bytes) != n_bytes)
02531 {
02532 _dbus_close (fd, NULL);
02533 _dbus_string_set_length (str, old_len);
02534 return _dbus_generate_pseudorandom_bytes (str, n_bytes);
02535 }
02536
02537 _dbus_verbose ("Read %d bytes from /dev/urandom\n",
02538 n_bytes);
02539
02540 _dbus_close (fd, NULL);
02541
02542 return TRUE;
02543 }
02544
02550 void
02551 _dbus_exit (int code)
02552 {
02553 _exit (code);
02554 }
02555
02564 const char*
02565 _dbus_strerror (int error_number)
02566 {
02567 const char *msg;
02568
02569 msg = strerror (error_number);
02570 if (msg == NULL)
02571 msg = "unknown";
02572
02573 return msg;
02574 }
02575
02579 void
02580 _dbus_disable_sigpipe (void)
02581 {
02582 signal (SIGPIPE, SIG_IGN);
02583 }
02584
02592 void
02593 _dbus_fd_set_close_on_exec (int fd)
02594 {
02595 int val;
02596
02597 val = fcntl (fd, F_GETFD, 0);
02598
02599 if (val < 0)
02600 return;
02601
02602 val |= FD_CLOEXEC;
02603
02604 fcntl (fd, F_SETFD, val);
02605 }
02606
02614 dbus_bool_t
02615 _dbus_close (int fd,
02616 DBusError *error)
02617 {
02618 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02619
02620 again:
02621 if (close (fd) < 0)
02622 {
02623 if (errno == EINTR)
02624 goto again;
02625
02626 dbus_set_error (error, _dbus_error_from_errno (errno),
02627 "Could not close fd %d", fd);
02628 return FALSE;
02629 }
02630
02631 return TRUE;
02632 }
02633
02641 dbus_bool_t
02642 _dbus_set_fd_nonblocking (int fd,
02643 DBusError *error)
02644 {
02645 int val;
02646
02647 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02648
02649 val = fcntl (fd, F_GETFL, 0);
02650 if (val < 0)
02651 {
02652 dbus_set_error (error, _dbus_error_from_errno (errno),
02653 "Failed to get flags from file descriptor %d: %s",
02654 fd, _dbus_strerror (errno));
02655 _dbus_verbose ("Failed to get flags for fd %d: %s\n", fd,
02656 _dbus_strerror (errno));
02657 return FALSE;
02658 }
02659
02660 if (fcntl (fd, F_SETFL, val | O_NONBLOCK) < 0)
02661 {
02662 dbus_set_error (error, _dbus_error_from_errno (errno),
02663 "Failed to set nonblocking flag of file descriptor %d: %s",
02664 fd, _dbus_strerror (errno));
02665 _dbus_verbose ("Failed to set fd %d nonblocking: %s\n",
02666 fd, _dbus_strerror (errno));
02667
02668 return FALSE;
02669 }
02670
02671 return TRUE;
02672 }
02673
02679 void
02680 _dbus_print_backtrace (void)
02681 {
02682 #if defined (HAVE_BACKTRACE) && defined (DBUS_BUILT_R_DYNAMIC)
02683 void *bt[500];
02684 int bt_size;
02685 int i;
02686 char **syms;
02687
02688 bt_size = backtrace (bt, 500);
02689
02690 syms = backtrace_symbols (bt, bt_size);
02691
02692 i = 0;
02693 while (i < bt_size)
02694 {
02695
02696 fprintf (stderr, " %s\n", syms[i]);
02697 ++i;
02698 }
02699 fflush (stderr);
02700
02701 free (syms);
02702 #elif defined (HAVE_BACKTRACE) && ! defined (DBUS_BUILT_R_DYNAMIC)
02703 fprintf (stderr, " D-Bus not built with -rdynamic so unable to print a backtrace\n");
02704 #else
02705 fprintf (stderr, " D-Bus not compiled with backtrace support so unable to print a backtrace\n");
02706 #endif
02707 }
02708
02724 dbus_bool_t
02725 _dbus_full_duplex_pipe (int *fd1,
02726 int *fd2,
02727 dbus_bool_t blocking,
02728 DBusError *error)
02729 {
02730 #ifdef HAVE_SOCKETPAIR
02731 int fds[2];
02732
02733 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02734
02735 if (socketpair (AF_UNIX, SOCK_STREAM, 0, fds) < 0)
02736 {
02737 dbus_set_error (error, _dbus_error_from_errno (errno),
02738 "Could not create full-duplex pipe");
02739 return FALSE;
02740 }
02741
02742 if (!blocking &&
02743 (!_dbus_set_fd_nonblocking (fds[0], NULL) ||
02744 !_dbus_set_fd_nonblocking (fds[1], NULL)))
02745 {
02746 dbus_set_error (error, _dbus_error_from_errno (errno),
02747 "Could not set full-duplex pipe nonblocking");
02748
02749 _dbus_close (fds[0], NULL);
02750 _dbus_close (fds[1], NULL);
02751
02752 return FALSE;
02753 }
02754
02755 *fd1 = fds[0];
02756 *fd2 = fds[1];
02757
02758 _dbus_verbose ("full-duplex pipe %d <-> %d\n",
02759 *fd1, *fd2);
02760
02761 return TRUE;
02762 #else
02763 _dbus_warn ("_dbus_full_duplex_pipe() not implemented on this OS\n");
02764 dbus_set_error (error, DBUS_ERROR_FAILED,
02765 "_dbus_full_duplex_pipe() not implemented on this OS");
02766 return FALSE;
02767 #endif
02768 }
02769
02770
02779 int
02780 _dbus_printf_string_upper_bound (const char *format,
02781 va_list args)
02782 {
02783 char c;
02784 return vsnprintf (&c, 1, format, args);
02785 }
02786
02793 const char*
02794 _dbus_get_tmpdir(void)
02795 {
02796 static const char* tmpdir = NULL;
02797
02798 if (tmpdir == NULL)
02799 {
02800
02801
02802
02803
02804 if (tmpdir == NULL)
02805 tmpdir = getenv("TMPDIR");
02806
02807
02808
02809
02810 if (tmpdir == NULL)
02811 tmpdir = getenv("TMP");
02812 if (tmpdir == NULL)
02813 tmpdir = getenv("TEMP");
02814
02815
02816 if (tmpdir == NULL)
02817 tmpdir = "/tmp";
02818 }
02819
02820 _dbus_assert(tmpdir != NULL);
02821
02822 return tmpdir;
02823 }
02824
02837 dbus_bool_t
02838 _dbus_get_autolaunch_address (DBusString *address,
02839 DBusError *error)
02840 {
02841 static char *argv[6];
02842 int address_pipe[2] = { -1, -1 };
02843 int errors_pipe[2] = { -1, -1 };
02844 pid_t pid;
02845 int ret;
02846 int status;
02847 int orig_len;
02848 int i;
02849 DBusString uuid;
02850 dbus_bool_t retval;
02851
02852 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
02853 retval = FALSE;
02854
02855 if (!_dbus_string_init (&uuid))
02856 {
02857 _DBUS_SET_OOM (error);
02858 return FALSE;
02859 }
02860
02861 if (!_dbus_get_local_machine_uuid_encoded (&uuid))
02862 {
02863 _DBUS_SET_OOM (error);
02864 goto out;
02865 }
02866
02867 i = 0;
02868 argv[i] = "dbus-launch";
02869 ++i;
02870 argv[i] = "--autolaunch";
02871 ++i;
02872 argv[i] = _dbus_string_get_data (&uuid);
02873 ++i;
02874 argv[i] = "--binary-syntax";
02875 ++i;
02876 argv[i] = "--close-stderr";
02877 ++i;
02878 argv[i] = NULL;
02879 ++i;
02880
02881 _dbus_assert (i == _DBUS_N_ELEMENTS (argv));
02882
02883 orig_len = _dbus_string_get_length (address);
02884
02885 #define READ_END 0
02886 #define WRITE_END 1
02887 if (pipe (address_pipe) < 0)
02888 {
02889 dbus_set_error (error, _dbus_error_from_errno (errno),
02890 "Failed to create a pipe: %s",
02891 _dbus_strerror (errno));
02892 _dbus_verbose ("Failed to create a pipe to call dbus-launch: %s\n",
02893 _dbus_strerror (errno));
02894 goto out;
02895 }
02896 if (pipe (errors_pipe) < 0)
02897 {
02898 dbus_set_error (error, _dbus_error_from_errno (errno),
02899 "Failed to create a pipe: %s",
02900 _dbus_strerror (errno));
02901 _dbus_verbose ("Failed to create a pipe to call dbus-launch: %s\n",
02902 _dbus_strerror (errno));
02903 goto out;
02904 }
02905
02906 pid = fork ();
02907 if (pid < 0)
02908 {
02909 dbus_set_error (error, _dbus_error_from_errno (errno),
02910 "Failed to fork(): %s",
02911 _dbus_strerror (errno));
02912 _dbus_verbose ("Failed to fork() to call dbus-launch: %s\n",
02913 _dbus_strerror (errno));
02914 goto out;
02915 }
02916
02917 if (pid == 0)
02918 {
02919
02920 int maxfds;
02921 int fd;
02922
02923 fd = open ("/dev/null", O_RDWR);
02924 if (fd == -1)
02925
02926 _exit (1);
02927
02928 _dbus_verbose ("/dev/null fd %d opened\n", fd);
02929
02930
02931 close (address_pipe[READ_END]);
02932 close (errors_pipe[READ_END]);
02933 close (0);
02934 close (1);
02935 close (2);
02936
02937 if (dup2 (fd, 0) == -1)
02938 _exit (1);
02939 if (dup2 (address_pipe[WRITE_END], 1) == -1)
02940 _exit (1);
02941 if (dup2 (errors_pipe[WRITE_END], 2) == -1)
02942 _exit (1);
02943
02944 maxfds = sysconf (_SC_OPEN_MAX);
02945
02946
02947
02948 if (maxfds < 0)
02949 maxfds = 1024;
02950
02951 for (i = 3; i < maxfds; i++)
02952 close (i);
02953
02954 execv (DBUS_BINDIR "/dbus-launch", argv);
02955
02956
02957 execvp ("dbus-launch", argv);
02958
02959
02960 _exit (1);
02961 }
02962
02963
02964 close (address_pipe[WRITE_END]);
02965 close (errors_pipe[WRITE_END]);
02966 address_pipe[WRITE_END] = -1;
02967 errors_pipe[WRITE_END] = -1;
02968
02969 ret = 0;
02970 do
02971 {
02972 ret = _dbus_read (address_pipe[READ_END], address, 1024);
02973 }
02974 while (ret > 0);
02975
02976
02977 do
02978 {
02979 ret = waitpid (pid, &status, 0);
02980 }
02981 while (ret == -1 && errno == EINTR);
02982
02983
02984
02985 if (!WIFEXITED (status) || WEXITSTATUS (status) != 0 ||
02986 _dbus_string_get_length (address) == orig_len)
02987 {
02988
02989 DBusString error_message;
02990 _dbus_string_init (&error_message);
02991 ret = 0;
02992 do
02993 {
02994 ret = _dbus_read (errors_pipe[READ_END], &error_message, 1024);
02995 }
02996 while (ret > 0);
02997
02998 _dbus_string_set_length (address, orig_len);
02999 if (_dbus_string_get_length (&error_message) > 0)
03000 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
03001 "dbus-launch failed to autolaunch D-Bus session: %s",
03002 _dbus_string_get_data (&error_message));
03003 else
03004 dbus_set_error (error, DBUS_ERROR_SPAWN_EXEC_FAILED,
03005 "Failed to execute dbus-launch to autolaunch D-Bus session");
03006 goto out;
03007 }
03008
03009 retval = TRUE;
03010
03011 out:
03012 if (retval)
03013 _DBUS_ASSERT_ERROR_IS_CLEAR (error);
03014 else
03015 _DBUS_ASSERT_ERROR_IS_SET (error);
03016
03017 if (address_pipe[0] != -1)
03018 close (address_pipe[0]);
03019 if (address_pipe[1] != -1)
03020 close (address_pipe[1]);
03021 if (errors_pipe[0] != -1)
03022 close (errors_pipe[0]);
03023 if (errors_pipe[1] != -1)
03024 close (errors_pipe[1]);
03025
03026 _dbus_string_free (&uuid);
03027 return retval;
03028 }
03029
03048 dbus_bool_t
03049 _dbus_read_local_machine_uuid (DBusGUID *machine_id,
03050 dbus_bool_t create_if_not_found,
03051 DBusError *error)
03052 {
03053 DBusString filename;
03054 _dbus_string_init_const (&filename, DBUS_MACHINE_UUID_FILE);
03055 return _dbus_read_uuid_file (&filename, machine_id, create_if_not_found, error);
03056 }
03057
03058 #define DBUS_UNIX_STANDARD_SESSION_SERVICEDIR "/dbus-1/services"
03059 #define DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR "/dbus-1/system-services"
03060
03061
03079 dbus_bool_t
03080 _dbus_get_standard_session_servicedirs (DBusList **dirs)
03081 {
03082 const char *xdg_data_home;
03083 const char *xdg_data_dirs;
03084 DBusString servicedir_path;
03085
03086 if (!_dbus_string_init (&servicedir_path))
03087 return FALSE;
03088
03089 xdg_data_home = _dbus_getenv ("XDG_DATA_HOME");
03090 xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
03091
03092 if (xdg_data_dirs != NULL)
03093 {
03094 if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
03095 goto oom;
03096
03097 if (!_dbus_string_append (&servicedir_path, ":"))
03098 goto oom;
03099 }
03100 else
03101 {
03102 if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
03103 goto oom;
03104 }
03105
03106
03107
03108
03109
03110
03111
03112 if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR":"))
03113 goto oom;
03114
03115 if (xdg_data_home != NULL)
03116 {
03117 if (!_dbus_string_append (&servicedir_path, xdg_data_home))
03118 goto oom;
03119 }
03120 else
03121 {
03122 const DBusString *homedir;
03123 DBusString local_share;
03124
03125 if (!_dbus_homedir_from_current_process (&homedir))
03126 goto oom;
03127
03128 if (!_dbus_string_append (&servicedir_path, _dbus_string_get_const_data (homedir)))
03129 goto oom;
03130
03131 _dbus_string_init_const (&local_share, "/.local/share");
03132 if (!_dbus_concat_dir_and_file (&servicedir_path, &local_share))
03133 goto oom;
03134 }
03135
03136 if (!_dbus_split_paths_and_append (&servicedir_path,
03137 DBUS_UNIX_STANDARD_SESSION_SERVICEDIR,
03138 dirs))
03139 goto oom;
03140
03141 _dbus_string_free (&servicedir_path);
03142 return TRUE;
03143
03144 oom:
03145 _dbus_string_free (&servicedir_path);
03146 return FALSE;
03147 }
03148
03149
03168 dbus_bool_t
03169 _dbus_get_standard_system_servicedirs (DBusList **dirs)
03170 {
03171 const char *xdg_data_dirs;
03172 DBusString servicedir_path;
03173
03174 if (!_dbus_string_init (&servicedir_path))
03175 return FALSE;
03176
03177 xdg_data_dirs = _dbus_getenv ("XDG_DATA_DIRS");
03178
03179 if (xdg_data_dirs != NULL)
03180 {
03181 if (!_dbus_string_append (&servicedir_path, xdg_data_dirs))
03182 goto oom;
03183
03184 if (!_dbus_string_append (&servicedir_path, ":"))
03185 goto oom;
03186 }
03187 else
03188 {
03189 if (!_dbus_string_append (&servicedir_path, "/usr/local/share:/usr/share:"))
03190 goto oom;
03191 }
03192
03193
03194
03195
03196
03197
03198
03199 if (!_dbus_string_append (&servicedir_path, DBUS_DATADIR":"))
03200 goto oom;
03201
03202 if (!_dbus_split_paths_and_append (&servicedir_path,
03203 DBUS_UNIX_STANDARD_SYSTEM_SERVICEDIR,
03204 dirs))
03205 goto oom;
03206
03207 _dbus_string_free (&servicedir_path);
03208 return TRUE;
03209
03210 oom:
03211 _dbus_string_free (&servicedir_path);
03212 return FALSE;
03213 }
03214
03223 dbus_bool_t
03224 _dbus_append_system_config_file (DBusString *str)
03225 {
03226 return _dbus_string_append (str, DBUS_SYSTEM_CONFIG_FILE);
03227 }
03228
03235 dbus_bool_t
03236 _dbus_append_session_config_file (DBusString *str)
03237 {
03238 return _dbus_string_append (str, DBUS_SESSION_CONFIG_FILE);
03239 }
03240
03248 void
03249 _dbus_flush_caches (void)
03250 {
03251 _dbus_user_database_flush_system ();
03252 }
03253
03267 dbus_bool_t
03268 _dbus_append_keyring_directory_for_credentials (DBusString *directory,
03269 DBusCredentials *credentials)
03270 {
03271 DBusString homedir;
03272 DBusString dotdir;
03273 dbus_uid_t uid;
03274
03275 _dbus_assert (credentials != NULL);
03276 _dbus_assert (!_dbus_credentials_are_anonymous (credentials));
03277
03278 if (!_dbus_string_init (&homedir))
03279 return FALSE;
03280
03281 uid = _dbus_credentials_get_unix_uid (credentials);
03282 _dbus_assert (uid != DBUS_UID_UNSET);
03283
03284 if (!_dbus_homedir_from_uid (uid, &homedir))
03285 goto failed;
03286
03287 #ifdef DBUS_BUILD_TESTS
03288 {
03289 const char *override;
03290
03291 override = _dbus_getenv ("DBUS_TEST_HOMEDIR");
03292 if (override != NULL && *override != '\0')
03293 {
03294 _dbus_string_set_length (&homedir, 0);
03295 if (!_dbus_string_append (&homedir, override))
03296 goto failed;
03297
03298 _dbus_verbose ("Using fake homedir for testing: %s\n",
03299 _dbus_string_get_const_data (&homedir));
03300 }
03301 else
03302 {
03303 static dbus_bool_t already_warned = FALSE;
03304 if (!already_warned)
03305 {
03306 _dbus_warn ("Using your real home directory for testing, set DBUS_TEST_HOMEDIR to avoid\n");
03307 already_warned = TRUE;
03308 }
03309 }
03310 }
03311 #endif
03312
03313 _dbus_string_init_const (&dotdir, ".dbus-keyrings");
03314 if (!_dbus_concat_dir_and_file (&homedir,
03315 &dotdir))
03316 goto failed;
03317
03318 if (!_dbus_string_copy (&homedir, 0,
03319 directory, _dbus_string_get_length (directory))) {
03320 goto failed;
03321 }
03322
03323 _dbus_string_free (&homedir);
03324 return TRUE;
03325
03326 failed:
03327 _dbus_string_free (&homedir);
03328 return FALSE;
03329 }
03330
03331
03338 dbus_bool_t
03339 _dbus_get_is_errno_eagain_or_ewouldblock (void)
03340 {
03341 return errno == EAGAIN || errno == EWOULDBLOCK;
03342 }
03343
03344