dbus/dbus-sysdeps.c

   1 /* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
   2 /* dbus-sysdeps.c Wrappers around system/libc features shared between UNIX and Windows (internal to D-Bus implementation)
   3  *
   4  * Copyright (C) 2002, 2003, 2006  Red Hat, Inc.
   5  * Copyright (C) 2003 CodeFactory AB
   6  *
   7  * Licensed under the Academic Free License version 2.1
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  22  *
  23  */
  24
  25 #include <config.h>
  26 #include "dbus-internals.h"
  27 #include "dbus-sysdeps.h"
  28 #include "dbus-threads.h"
  29 #include "dbus-protocol.h"
  30 #include "dbus-string.h"
  31 #include "dbus-list.h"
  32
  33 /* NOTE: If you include any unix/windows-specific headers here, you are probably doing something
  34  * wrong and should be putting some code in dbus-sysdeps-unix.c or dbus-sysdeps-win.c.
  35  *
  36  * These are the standard ANSI C headers...
  37  */
  38 #if HAVE_LOCALE_H
  39 #include <locale.h>
  40 #endif
  41 #include <stdlib.h>
  42 #include <string.h>
  43 #include <stdio.h>
  44
  45 #ifdef HAVE_ERRNO_H
  46 #include <errno.h>
  47 #endif
  48
  49 _DBUS_DEFINE_GLOBAL_LOCK (win_fds);
  50 _DBUS_DEFINE_GLOBAL_LOCK (sid_atom_cache);
  51 _DBUS_DEFINE_GLOBAL_LOCK (system_users);
  52
  53 #ifdef DBUS_WIN
  54   #include <stdlib.h>
  55 #elif (defined __APPLE__)
  56 # include <crt_externs.h>
  57 # define environ (*_NSGetEnviron())
  58 #else
  59 extern char **environ;
  60 #endif
  61
  62 /**
  63  * @defgroup DBusSysdeps Internal system-dependent API
  64  * @ingroup DBusInternals
  65  * @brief Internal system-dependent API available on UNIX and Windows
  66  *
  67  * The system-dependent API has a dual purpose. First, it encapsulates
  68  * all usage of operating system APIs for ease of auditing and to
  69  * avoid cluttering the rest of the code with bizarre OS quirks and
  70  * headers. Second, it abstracts different operating system APIs for
  71  * portability.
  72  *
  73  * @{
  74  */
  75
  76 /**
  77  * Aborts the program with SIGABRT (dumping core).
  78  */
  79 void
  80 _dbus_abort (void)
  81 {
  82   const char *s;
  83
  84   _dbus_print_backtrace ();
  85
  86   s = _dbus_getenv ("DBUS_BLOCK_ON_ABORT");
  87   if (s && *s)
  88     {
  89       /* don't use _dbus_warn here since it can _dbus_abort() */
  90       fprintf (stderr, "  Process %lu sleeping for gdb attach\n", _dbus_pid_for_log ());
  91       _dbus_sleep_milliseconds (1000 * 180);
  92     }
  93
  94   abort ();
  95   _dbus_exit (1); /* in case someone manages to ignore SIGABRT ? */
  96 }
  97
  98 /**
  99  * Wrapper for setenv(). If the value is #NULL, unsets
 100  * the environment variable.
 101  *
 102  * There is an unfixable memleak in that it is unsafe to
 103  * free memory malloced for use with setenv. This is because
 104  * we can not rely on internal implementation details of
 105  * the underlying libc library.
 106  *
 107  * @param varname name of environment variable
 108  * @param value value of environment variable
 109  * @returns #TRUE on success.
 110  */
 111 dbus_bool_t
 112 _dbus_setenv (const char *varname,
 113               const char *value)
 114 {
 115   _dbus_assert (varname != NULL);
 116
 117   if (value == NULL)
 118     {
 119 #ifdef HAVE_UNSETENV
 120       unsetenv (varname);
 121       return TRUE;
 122 #else
 123       char *putenv_value;
 124       size_t len;
 125
 126       len = strlen (varname);
 127
 128       /* Use system malloc to avoid memleaks that dbus_malloc
 129        * will get upset about.
 130        */
 131
 132       putenv_value = malloc (len + 2);
 133       if (putenv_value == NULL)
 134         return FALSE;
 135
 136       strcpy (putenv_value, varname);
 137 #if defined(DBUS_WIN)
 138       strcat (putenv_value, "=");
 139 #endif
 140
 141       return (putenv (putenv_value) == 0);
 142 #endif
 143     }
 144   else
 145     {
 146 #ifdef HAVE_SETENV
 147       return (setenv (varname, value, TRUE) == 0);
 148 #else
 149       char *putenv_value;
 150       size_t len;
 151       size_t varname_len;
 152       size_t value_len;
 153
 154       varname_len = strlen (varname);
 155       value_len = strlen (value);
 156
 157       len = varname_len + value_len + 1 /* '=' */ ;
 158
 159       /* Use system malloc to avoid memleaks that dbus_malloc
 160        * will get upset about.
 161        */
 162
 163       putenv_value = malloc (len + 1);
 164       if (putenv_value == NULL)
 165         return FALSE;
 166
 167       strcpy (putenv_value, varname);
 168       strcpy (putenv_value + varname_len, "=");
 169       strcpy (putenv_value + varname_len + 1, value);
 170
 171       return (putenv (putenv_value) == 0);
 172 #endif
 173     }
 174 }
 175
 176 /**
 177  * Wrapper for getenv().
 178  *
 179  * @param varname name of environment variable
 180  * @returns value of environment variable or #NULL if unset
 181  */
 182 const char*
 183 _dbus_getenv (const char *varname)
 184 {
 185   /* Don't respect any environment variables if the current process is
 186    * setuid.  This is the equivalent of glibc's __secure_getenv().
 187    */
 188   if (_dbus_check_setuid ())
 189     return NULL;
 190   return getenv (varname);
 191 }
 192
 193 /**
 194  * Wrapper for clearenv().
 195  *
 196  * @returns #TRUE on success.
 197  */
 198 dbus_bool_t
 199 _dbus_clearenv (void)
 200 {
 201   dbus_bool_t rc = TRUE;
 202
 203 #ifdef HAVE_CLEARENV
 204   if (clearenv () != 0)
 205      rc = FALSE;
 206 #else
 207
 208   if (environ != NULL)
 209     environ[0] = NULL;
 210 #endif
 211
 212   return rc;
 213 }
 214
 215 /**
 216  * Split paths into a list of char strings
 217  *
 218  * @param dirs string with pathes
 219  * @param suffix string concated to each path in dirs
 220  * @param dir_list contains a list of splitted pathes
 221  * return #TRUE is pathes could be splittes,#FALSE in oom case
 222  */
 223 dbus_bool_t
 224 _dbus_split_paths_and_append (DBusString *dirs,
 225                               const char *suffix,
 226                               DBusList  **dir_list)
 227 {
 228    int start;
 229    int i;
 230    int len;
 231    char *cpath;
 232    DBusString file_suffix;
 233
 234    start = 0;
 235    i = 0;
 236
 237    _dbus_string_init_const (&file_suffix, suffix);
 238
 239    len = _dbus_string_get_length (dirs);
 240
 241    while (_dbus_string_find (dirs, start, _DBUS_PATH_SEPARATOR, &i))
 242      {
 243        DBusString path;
 244
 245        if (!_dbus_string_init (&path))
 246           goto oom;
 247
 248        if (!_dbus_string_copy_len (dirs,
 249                                    start,
 250                                    i - start,
 251                                    &path,
 252                                    0))
 253           {
 254             _dbus_string_free (&path);
 255             goto oom;
 256           }
 257
 258         _dbus_string_chop_white (&path);
 259
 260         /* check for an empty path */
 261         if (_dbus_string_get_length (&path) == 0)
 262           goto next;
 263
 264         if (!_dbus_concat_dir_and_file (&path,
 265                                         &file_suffix))
 266           {
 267             _dbus_string_free (&path);
 268             goto oom;
 269           }
 270
 271         if (!_dbus_string_copy_data(&path, &cpath))
 272           {
 273             _dbus_string_free (&path);
 274             goto oom;
 275           }
 276
 277         if (!_dbus_list_append (dir_list, cpath))
 278           {
 279             _dbus_string_free (&path);
 280             dbus_free (cpath);
 281             goto oom;
 282           }
 283
 284        next:
 285         _dbus_string_free (&path);
 286         start = i + 1;
 287     }
 288
 289   if (start != len)
 290     {
 291       DBusString path;
 292
 293       if (!_dbus_string_init (&path))
 294         goto oom;
 295
 296       if (!_dbus_string_copy_len (dirs,
 297                                   start,
 298                                   len - start,
 299                                   &path,
 300                                   0))
 301         {
 302           _dbus_string_free (&path);
 303           goto oom;
 304         }
 305
 306       if (!_dbus_concat_dir_and_file (&path,
 307                                       &file_suffix))
 308         {
 309           _dbus_string_free (&path);
 310           goto oom;
 311         }
 312
 313       if (!_dbus_string_copy_data(&path, &cpath))
 314         {
 315           _dbus_string_free (&path);
 316           goto oom;
 317         }
 318
 319       if (!_dbus_list_append (dir_list, cpath))
 320         {
 321           _dbus_string_free (&path);
 322           dbus_free (cpath);
 323           goto oom;
 324         }
 325
 326       _dbus_string_free (&path);
 327     }
 328
 329   return TRUE;
 330
 331  oom:
 332   _dbus_list_foreach (dir_list, (DBusForeachFunction)dbus_free, NULL);
 333   _dbus_list_clear (dir_list);
 334   return FALSE;
 335 }
 336
 337 /** @} */
 338
 339 /**
 340  * @addtogroup DBusString
 341  *
 342  * @{
 343  */
 344 /**
 345  * Appends an integer to a DBusString.
 346  *
 347  * @param str the string
 348  * @param value the integer value
 349  * @returns #FALSE if not enough memory or other failure.
 350  */
 351 dbus_bool_t
 352 _dbus_string_append_int (DBusString *str,
 353                          long        value)
 354 {
 355   /* this calculation is from comp.lang.c faq */
 356 #define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1)  /* +1 for '-' */
 357   int orig_len;
 358   int i;
 359   char *buf;
 360
 361   orig_len = _dbus_string_get_length (str);
 362
 363   if (!_dbus_string_lengthen (str, MAX_LONG_LEN))
 364     return FALSE;
 365
 366   buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);
 367
 368   snprintf (buf, MAX_LONG_LEN, "%ld", value);
 369
 370   i = 0;
 371   while (*buf)
 372     {
 373       ++buf;
 374       ++i;
 375     }
 376
 377   _dbus_string_shorten (str, MAX_LONG_LEN - i);
 378
 379   return TRUE;
 380 }
 381
 382 /**
 383  * Appends an unsigned integer to a DBusString.
 384  *
 385  * @param str the string
 386  * @param value the integer value
 387  * @returns #FALSE if not enough memory or other failure.
 388  */
 389 dbus_bool_t
 390 _dbus_string_append_uint (DBusString    *str,
 391                           unsigned long  value)
 392 {
 393   /* this is wrong, but definitely on the high side. */
 394 #define MAX_ULONG_LEN (MAX_LONG_LEN * 2)
 395   int orig_len;
 396   int i;
 397   char *buf;
 398
 399   orig_len = _dbus_string_get_length (str);
 400
 401   if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))
 402     return FALSE;
 403
 404   buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);
 405
 406   snprintf (buf, MAX_ULONG_LEN, "%lu", value);
 407
 408   i = 0;
 409   while (*buf)
 410     {
 411       ++buf;
 412       ++i;
 413     }
 414
 415   _dbus_string_shorten (str, MAX_ULONG_LEN - i);
 416
 417   return TRUE;
 418 }
 419
 420 /**
 421  * Parses an integer contained in a DBusString. Either return parameter
 422  * may be #NULL if you aren't interested in it. The integer is parsed
 423  * and stored in value_return. Return parameters are not initialized
 424  * if the function returns #FALSE.
 425  *
 426  * @param str the string
 427  * @param start the byte index of the start of the integer
 428  * @param value_return return location of the integer value or #NULL
 429  * @param end_return return location of the end of the integer, or #NULL
 430  * @returns #TRUE on success
 431  */
 432 dbus_bool_t
 433 _dbus_string_parse_int (const DBusString *str,
 434                         int               start,
 435                         long             *value_return,
 436                         int              *end_return)
 437 {
 438   long v;
 439   const char *p;
 440   char *end;
 441
 442   p = _dbus_string_get_const_data_len (str, start,
 443                                        _dbus_string_get_length (str) - start);
 444
 445   end = NULL;
 446   _dbus_set_errno_to_zero ();
 447   v = strtol (p, &end, 0);
 448   if (end == NULL || end == p || errno != 0)
 449     return FALSE;
 450
 451   if (value_return)
 452     *value_return = v;
 453   if (end_return)
 454     *end_return = start + (end - p);
 455
 456   return TRUE;
 457 }
 458
 459 /**
 460  * Parses an unsigned integer contained in a DBusString. Either return
 461  * parameter may be #NULL if you aren't interested in it. The integer
 462  * is parsed and stored in value_return. Return parameters are not
 463  * initialized if the function returns #FALSE.
 464  *
 465  * @param str the string
 466  * @param start the byte index of the start of the integer
 467  * @param value_return return location of the integer value or #NULL
 468  * @param end_return return location of the end of the integer, or #NULL
 469  * @returns #TRUE on success
 470  */
 471 dbus_bool_t
 472 _dbus_string_parse_uint (const DBusString *str,
 473                          int               start,
 474                          unsigned long    *value_return,
 475                          int              *end_return)
 476 {
 477   unsigned long v;
 478   const char *p;
 479   char *end;
 480
 481   p = _dbus_string_get_const_data_len (str, start,
 482                                        _dbus_string_get_length (str) - start);
 483
 484   end = NULL;
 485   _dbus_set_errno_to_zero ();
 486   v = strtoul (p, &end, 0);
 487   if (end == NULL || end == p || errno != 0)
 488     return FALSE;
 489
 490   if (value_return)
 491     *value_return = v;
 492   if (end_return)
 493     *end_return = start + (end - p);
 494
 495   return TRUE;
 496 }
 497
 498 /** @} */ /* DBusString group */
 499
 500 /**
 501  * @addtogroup DBusInternalsUtils
 502  * @{
 503  */
 504
 505 void
 506 _dbus_generate_pseudorandom_bytes_buffer (char *buffer,
 507                                           int   n_bytes)
 508 {
 509   long tv_usec;
 510   int i;
 511
 512   /* fall back to pseudorandom */
 513   _dbus_verbose ("Falling back to pseudorandom for %d bytes\n",
 514                  n_bytes);
 515
 516   _dbus_get_real_time (NULL, &tv_usec);
 517   srand (tv_usec);
 518
 519   i = 0;
 520   while (i < n_bytes)
 521     {
 522       double r;
 523       unsigned int b;
 524
 525       r = rand ();
 526       b = (r / (double) RAND_MAX) * 255.0;
 527
 528       buffer[i] = b;
 529
 530       ++i;
 531     }
 532 }
 533
 534 /**
 535  * Fills n_bytes of the given buffer with random bytes.
 536  *
 537  * @param buffer an allocated buffer
 538  * @param n_bytes the number of bytes in buffer to write to
 539  */
 540 void
 541 _dbus_generate_random_bytes_buffer (char *buffer,
 542                                     int   n_bytes)
 543 {
 544   DBusString str;
 545
 546   if (!_dbus_string_init (&str))
 547     {
 548       _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes);
 549       return;
 550     }
 551
 552   if (!_dbus_generate_random_bytes (&str, n_bytes))
 553     {
 554       _dbus_string_free (&str);
 555       _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes);
 556       return;
 557     }
 558
 559   _dbus_string_copy_to_buffer (&str, buffer, n_bytes);
 560
 561   _dbus_string_free (&str);
 562 }
 563
 564 /**
 565  * Generates the given number of random bytes, where the bytes are
 566  * chosen from the alphanumeric ASCII subset.
 567  *
 568  * @param str the string
 569  * @param n_bytes the number of random ASCII bytes to append to string
 570  * @returns #TRUE on success, #FALSE if no memory or other failure
 571  */
 572 dbus_bool_t
 573 _dbus_generate_random_ascii (DBusString *str,
 574                              int         n_bytes)
 575 {
 576   static const char letters[] =
 577     "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
 578   int i;
 579   int len;
 580
 581   if (!_dbus_generate_random_bytes (str, n_bytes))
 582     return FALSE;
 583
 584   len = _dbus_string_get_length (str);
 585   i = len - n_bytes;
 586   while (i < len)
 587     {
 588       _dbus_string_set_byte (str, i,
 589                              letters[_dbus_string_get_byte (str, i) %
 590                                      (sizeof (letters) - 1)]);
 591
 592       ++i;
 593     }
 594
 595   _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes,
 596                                              n_bytes));
 597
 598   return TRUE;
 599 }
 600
 601 /**
 602  * Converts a UNIX errno, or Windows errno or WinSock error value into
 603  * a #DBusError name.
 604  *
 605  * @todo should cover more errnos, specifically those
 606  * from open().
 607  *
 608  * @param error_number the errno.
 609  * @returns an error name
 610  */
 611 const char*
 612 _dbus_error_from_errno (int error_number)
 613 {
 614   switch (error_number)
 615     {
 616     case 0:
 617       return DBUS_ERROR_FAILED;
 618
 619 #ifdef EPROTONOSUPPORT
 620     case EPROTONOSUPPORT:
 621       return DBUS_ERROR_NOT_SUPPORTED;
 622 #elif defined(WSAEPROTONOSUPPORT)
 623     case WSAEPROTONOSUPPORT:
 624       return DBUS_ERROR_NOT_SUPPORTED;
 625 #endif
 626 #ifdef EAFNOSUPPORT
 627     case EAFNOSUPPORT:
 628       return DBUS_ERROR_NOT_SUPPORTED;
 629 #elif defined(WSAEAFNOSUPPORT)
 630     case WSAEAFNOSUPPORT:
 631       return DBUS_ERROR_NOT_SUPPORTED;
 632 #endif
 633 #ifdef ENFILE
 634     case ENFILE:
 635       return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */
 636 #endif
 637 #ifdef EMFILE
 638     case EMFILE:
 639       return DBUS_ERROR_LIMITS_EXCEEDED;
 640 #endif
 641 #ifdef EACCES
 642     case EACCES:
 643       return DBUS_ERROR_ACCESS_DENIED;
 644 #endif
 645 #ifdef EPERM
 646     case EPERM:
 647       return DBUS_ERROR_ACCESS_DENIED;
 648 #endif
 649 #ifdef ENOBUFS
 650     case ENOBUFS:
 651       return DBUS_ERROR_NO_MEMORY;
 652 #endif
 653 #ifdef ENOMEM
 654     case ENOMEM:
 655       return DBUS_ERROR_NO_MEMORY;
 656 #endif
 657 #ifdef ECONNREFUSED
 658     case ECONNREFUSED:
 659       return DBUS_ERROR_NO_SERVER;
 660 #elif defined(WSAECONNREFUSED)
 661     case WSAECONNREFUSED:
 662       return DBUS_ERROR_NO_SERVER;
 663 #endif
 664 #ifdef ETIMEDOUT
 665     case ETIMEDOUT:
 666       return DBUS_ERROR_TIMEOUT;
 667 #elif defined(WSAETIMEDOUT)
 668     case WSAETIMEDOUT:
 669       return DBUS_ERROR_TIMEOUT;
 670 #endif
 671 #ifdef ENETUNREACH
 672     case ENETUNREACH:
 673       return DBUS_ERROR_NO_NETWORK;
 674 #elif defined(WSAENETUNREACH)
 675     case WSAENETUNREACH:
 676       return DBUS_ERROR_NO_NETWORK;
 677 #endif
 678 #ifdef EADDRINUSE
 679     case EADDRINUSE:
 680       return DBUS_ERROR_ADDRESS_IN_USE;
 681 #elif defined(WSAEADDRINUSE)
 682     case WSAEADDRINUSE:
 683       return DBUS_ERROR_ADDRESS_IN_USE;
 684 #endif
 685 #ifdef EEXIST
 686     case EEXIST:
 687       return DBUS_ERROR_FILE_EXISTS;
 688 #endif
 689 #ifdef ENOENT
 690     case ENOENT:
 691       return DBUS_ERROR_FILE_NOT_FOUND;
 692 #endif
 693     }
 694
 695   return DBUS_ERROR_FAILED;
 696 }
 697
 698 /**
 699  * Converts the current system errno value into a #DBusError name.
 700  *
 701  * @returns an error name
 702  */
 703 const char*
 704 _dbus_error_from_system_errno (void)
 705 {
 706   return _dbus_error_from_errno (errno);
 707 }
 708
 709 /**
 710  * Assign 0 to the global errno variable
 711  */
 712 void
 713 _dbus_set_errno_to_zero (void)
 714 {
 715 #ifdef DBUS_WINCE
 716   SetLastError (0);
 717 #else
 718   errno = 0;
 719 #endif
 720 }
 721
 722 /**
 723  * See if errno is set
 724  * @returns #TRUE if errno is not 0
 725  */
 726 dbus_bool_t
 727 _dbus_get_is_errno_nonzero (void)
 728 {
 729   return errno != 0;
 730 }
 731
 732 /**
 733  * See if errno is ENOMEM
 734  * @returns #TRUE if errno == ENOMEM
 735  */
 736 dbus_bool_t
 737 _dbus_get_is_errno_enomem (void)
 738 {
 739   return errno == ENOMEM;
 740 }
 741
 742 /**
 743  * See if errno is EINTR
 744  * @returns #TRUE if errno == EINTR
 745  */
 746 dbus_bool_t
 747 _dbus_get_is_errno_eintr (void)
 748 {
 749   return errno == EINTR;
 750 }
 751
 752 /**
 753  * See if errno is EPIPE
 754  * @returns #TRUE if errno == EPIPE
 755  */
 756 dbus_bool_t
 757 _dbus_get_is_errno_epipe (void)
 758 {
 759   return errno == EPIPE;
 760 }
 761
 762 /**
 763  * Get error message from errno
 764  * @returns _dbus_strerror(errno)
 765  */
 766 const char*
 767 _dbus_strerror_from_errno (void)
 768 {
 769   return _dbus_strerror (errno);
 770 }
 771
 772 /** @} end of sysdeps */
 773
 774 /* tests in dbus-sysdeps-util.c */