dbus-sysdeps.c 17.2 KB
Newer Older
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 10 11 12 13 14 15 16 17 18 19 20
 * 
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * 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 34 35 36 37

/* NOTE: If you include any unix/windows-specific headers here, you are probably doing something
 * wrong and should be putting some code in dbus-sysdeps-unix.c or dbus-sysdeps-win.c.
 *
 * These are the standard ANSI C headers...
 */
38
#if HAVE_LOCALE_H
39
#include <locale.h>
40
#endif
41 42 43
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
44

45 46
#ifdef HAVE_ERRNO_H
#include <errno.h>
47 48
#endif

49 50
_DBUS_DEFINE_GLOBAL_LOCK (win_fds);
_DBUS_DEFINE_GLOBAL_LOCK (sid_atom_cache);
51
_DBUS_DEFINE_GLOBAL_LOCK (system_users);
52

53 54
#ifdef DBUS_WIN
  #include <stdlib.h>
55 56 57
#elif (defined __APPLE__)
# include <crt_externs.h>
# define environ (*_NSGetEnviron())
58
#else
Colin Walters's avatar
Colin Walters committed
59
extern char **environ;
60
#endif
Colin Walters's avatar
Colin Walters committed
61

62
/**
63 64 65 66 67 68 69 70 71 72
 * @defgroup DBusSysdeps Internal system-dependent API
 * @ingroup DBusInternals
 * @brief Internal system-dependent API available on UNIX and Windows
 *
 * The system-dependent API has a dual purpose. First, it encapsulates
 * all usage of operating system APIs for ease of auditing and to
 * avoid cluttering the rest of the code with bizarre OS quirks and
 * headers. Second, it abstracts different operating system APIs for
 * portability.
 * 
73 74
 * @{
 */
75

76 77 78 79 80 81
/**
 * Aborts the program with SIGABRT (dumping core).
 */
void
_dbus_abort (void)
{
82
  const char *s;
83 84 85
  
  _dbus_print_backtrace ();
  
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 100 101
 * Wrapper for setenv(). If the value is #NULL, unsets
 * the environment variable.
 *
102 103 104 105
 * There is an unfixable memleak in that it is unsafe to
 * free memory malloced for use with setenv. This is because
 * we can not rely on internal implementation details of
 * the underlying libc library.
106 107 108 109 110 111
 *
 * @param varname name of environment variable
 * @param value value of environment variable
 * @returns #TRUE on success.
 */
dbus_bool_t
112 113
_dbus_setenv (const char *varname,
              const char *value)
114
{
115 116 117 118 119 120 121
  _dbus_assert (varname != NULL);
  
  if (value == NULL)
    {
#ifdef HAVE_UNSETENV
      unsetenv (varname);
      return TRUE;
122
#else
123 124
      char *putenv_value;
      size_t len;
125

126
      len = strlen (varname);
127

128 129 130 131
      /* Use system malloc to avoid memleaks that dbus_malloc
       * will get upset about.
       */
      
132
      putenv_value = malloc (len + 2);
133 134 135 136
      if (putenv_value == NULL)
        return FALSE;

      strcpy (putenv_value, varname);
137 138 139
#if defined(DBUS_WIN)
      strcat (putenv_value, "=");
#endif
140 141 142
      
      return (putenv (putenv_value) == 0);
#endif
143
    }
144 145 146 147 148 149 150 151 152
  else
    {
#ifdef HAVE_SETENV
      return (setenv (varname, value, TRUE) == 0);
#else
      char *putenv_value;
      size_t len;
      size_t varname_len;
      size_t value_len;
153

154 155 156 157
      varname_len = strlen (varname);
      value_len = strlen (value);
      
      len = varname_len + value_len + 1 /* '=' */ ;
158

159 160 161 162 163 164 165 166 167 168 169 170 171
      /* Use system malloc to avoid memleaks that dbus_malloc
       * will get upset about.
       */
      
      putenv_value = malloc (len + 1);
      if (putenv_value == NULL)
        return FALSE;

      strcpy (putenv_value, varname);
      strcpy (putenv_value + varname_len, "=");
      strcpy (putenv_value + varname_len + 1, value);
      
      return (putenv (putenv_value) == 0);
172
#endif
173
    }
174 175
}

176 177 178 179 180 181 182 183 184 185 186 187
/**
 * Wrapper for getenv().
 *
 * @param varname name of environment variable
 * @returns value of environment variable or #NULL if unset
 */
const char*
_dbus_getenv (const char *varname)
{  
  return getenv (varname);
}

188 189 190 191 192 193 194 195
/**
 * Wrapper for clearenv().
 *
 * @returns #TRUE on success.
 */
dbus_bool_t
_dbus_clearenv (void)
{
196 197 198 199 200 201 202 203 204 205 206 207
  dbus_bool_t rc = TRUE;

#ifdef HAVE_CLEARENV
  if (clearenv () != 0)
     rc = FALSE;
#else

  if (environ != NULL)
    environ[0] = NULL;
#endif

  return rc;
208 209
}

210
/**
211 212
 * Split paths into a list of char strings
 * 
213 214 215 216 217 218 219 220 221 222 223 224 225 226
 * @param dirs string with pathes 
 * @param suffix string concated to each path in dirs
 * @param dir_list contains a list of splitted pathes
 * return #TRUE is pathes could be splittes,#FALSE in oom case 
 */
dbus_bool_t
_dbus_split_paths_and_append (DBusString *dirs, 
                              const char *suffix, 
                              DBusList  **dir_list)
{
   int start;
   int i;
   int len;
   char *cpath;
227
   DBusString file_suffix;
228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331

   start = 0;
   i = 0;

   _dbus_string_init_const (&file_suffix, suffix);

   len = _dbus_string_get_length (dirs);

   while (_dbus_string_find (dirs, start, _DBUS_PATH_SEPARATOR, &i))
     {
       DBusString path;

       if (!_dbus_string_init (&path))
          goto oom;

       if (!_dbus_string_copy_len (dirs,
                                   start,
                                   i - start,
                                   &path,
                                   0))
          {
            _dbus_string_free (&path);
            goto oom;
          }

        _dbus_string_chop_white (&path);

        /* check for an empty path */
        if (_dbus_string_get_length (&path) == 0)
          goto next;

        if (!_dbus_concat_dir_and_file (&path,
                                        &file_suffix))
          {
            _dbus_string_free (&path);
            goto oom;
          }

        if (!_dbus_string_copy_data(&path, &cpath))
          {
            _dbus_string_free (&path);
            goto oom;
          }

        if (!_dbus_list_append (dir_list, cpath))
          {
            _dbus_string_free (&path);              
            dbus_free (cpath);
            goto oom;
          }

       next:
        _dbus_string_free (&path);
        start = i + 1;
    } 
      
  if (start != len)
    { 
      DBusString path;

      if (!_dbus_string_init (&path))
        goto oom;

      if (!_dbus_string_copy_len (dirs,
                                  start,
                                  len - start,
                                  &path,
                                  0))
        {
          _dbus_string_free (&path);
          goto oom;
        }

      if (!_dbus_concat_dir_and_file (&path,
                                      &file_suffix))
        {
          _dbus_string_free (&path);
          goto oom;
        }

      if (!_dbus_string_copy_data(&path, &cpath))
        {
          _dbus_string_free (&path);
          goto oom;
        }

      if (!_dbus_list_append (dir_list, cpath))
        {
          _dbus_string_free (&path);              
          dbus_free (cpath);
          goto oom;
        }

      _dbus_string_free (&path); 
    }

  return TRUE;

 oom:
  _dbus_list_foreach (dir_list, (DBusForeachFunction)dbus_free, NULL); 
  _dbus_list_clear (dir_list);
  return FALSE;
}

332 333
/** @} */

334
/**
335
 * @addtogroup DBusString
336
 *
337
 * @{
338 339
 */
/**
340
 * Appends an integer to a DBusString.
341
 * 
342 343 344
 * @param str the string
 * @param value the integer value
 * @returns #FALSE if not enough memory or other failure.
345
 */
346 347 348
dbus_bool_t
_dbus_string_append_int (DBusString *str,
                         long        value)
349
{
350 351 352 353 354
  /* this calculation is from comp.lang.c faq */
#define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1)  /* +1 for '-' */
  int orig_len;
  int i;
  char *buf;
355
  
356
  orig_len = _dbus_string_get_length (str);
357

358 359
  if (!_dbus_string_lengthen (str, MAX_LONG_LEN))
    return FALSE;
360

361
  buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);
362

363
  snprintf (buf, MAX_LONG_LEN, "%ld", value);
364

365 366 367 368 369 370 371 372
  i = 0;
  while (*buf)
    {
      ++buf;
      ++i;
    }
  
  _dbus_string_shorten (str, MAX_LONG_LEN - i);
373
  
374
  return TRUE;
375 376 377
}

/**
378
 * Appends an unsigned integer to a DBusString.
379
 * 
380 381 382
 * @param str the string
 * @param value the integer value
 * @returns #FALSE if not enough memory or other failure.
383
 */
384 385 386
dbus_bool_t
_dbus_string_append_uint (DBusString    *str,
                          unsigned long  value)
387
{
388 389 390 391 392
  /* this is wrong, but definitely on the high side. */
#define MAX_ULONG_LEN (MAX_LONG_LEN * 2)
  int orig_len;
  int i;
  char *buf;
393
  
394
  orig_len = _dbus_string_get_length (str);
395

396 397
  if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))
    return FALSE;
398

399
  buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);
400

401
  snprintf (buf, MAX_ULONG_LEN, "%lu", value);
402

403 404
  i = 0;
  while (*buf)
405
    {
406 407
      ++buf;
      ++i;
408
    }
409 410 411 412
  
  _dbus_string_shorten (str, MAX_ULONG_LEN - i);
  
  return TRUE;
413 414
}

415
/**
416 417 418 419
 * Parses an integer contained in a DBusString. Either return parameter
 * may be #NULL if you aren't interested in it. The integer is parsed
 * and stored in value_return. Return parameters are not initialized
 * if the function returns #FALSE.
420
 *
421 422 423 424 425
 * @param str the string
 * @param start the byte index of the start of the integer
 * @param value_return return location of the integer value or #NULL
 * @param end_return return location of the end of the integer, or #NULL
 * @returns #TRUE on success
426
 */
427 428 429 430 431
dbus_bool_t
_dbus_string_parse_int (const DBusString *str,
                        int               start,
                        long             *value_return,
                        int              *end_return)
432
{
433 434 435
  long v;
  const char *p;
  char *end;
436

437 438
  p = _dbus_string_get_const_data_len (str, start,
                                       _dbus_string_get_length (str) - start);
439

440
  end = NULL;
441
  _dbus_set_errno_to_zero ();
442 443 444
  v = strtol (p, &end, 0);
  if (end == NULL || end == p || errno != 0)
    return FALSE;
445

446 447 448 449
  if (value_return)
    *value_return = v;
  if (end_return)
    *end_return = start + (end - p);
450

451
  return TRUE;
452 453 454
}

/**
455 456 457 458
 * Parses an unsigned integer contained in a DBusString. Either return
 * parameter may be #NULL if you aren't interested in it. The integer
 * is parsed and stored in value_return. Return parameters are not
 * initialized if the function returns #FALSE.
459
 *
460 461 462 463 464
 * @param str the string
 * @param start the byte index of the start of the integer
 * @param value_return return location of the integer value or #NULL
 * @param end_return return location of the end of the integer, or #NULL
 * @returns #TRUE on success
465
 */
466 467 468 469 470
dbus_bool_t
_dbus_string_parse_uint (const DBusString *str,
                         int               start,
                         unsigned long    *value_return,
                         int              *end_return)
471
{
472 473 474
  unsigned long v;
  const char *p;
  char *end;
475

476 477
  p = _dbus_string_get_const_data_len (str, start,
                                       _dbus_string_get_length (str) - start);
478

479
  end = NULL;
480
  _dbus_set_errno_to_zero ();
481 482 483
  v = strtoul (p, &end, 0);
  if (end == NULL || end == p || errno != 0)
    return FALSE;
484

485 486 487 488
  if (value_return)
    *value_return = v;
  if (end_return)
    *end_return = start + (end - p);
489 490 491 492

  return TRUE;
}

493
/** @} */ /* DBusString group */
494 495

/**
496 497
 * @addtogroup DBusInternalsUtils
 * @{
498 499
 */

500 501 502
void
_dbus_generate_pseudorandom_bytes_buffer (char *buffer,
                                          int   n_bytes)
503
{
504
  long tv_usec;
505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521
  int i;
  
  /* fall back to pseudorandom */
  _dbus_verbose ("Falling back to pseudorandom for %d bytes\n",
                 n_bytes);
  
  _dbus_get_current_time (NULL, &tv_usec);
  srand (tv_usec);
  
  i = 0;
  while (i < n_bytes)
    {
      double r;
      unsigned int b;
          
      r = rand ();
      b = (r / (double) RAND_MAX) * 255.0;
522 523 524

      buffer[i] = b;

525 526
      ++i;
    }
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
}

/**
 * Fills n_bytes of the given buffer with random bytes.
 *
 * @param buffer an allocated buffer
 * @param n_bytes the number of bytes in buffer to write to
 */
void
_dbus_generate_random_bytes_buffer (char *buffer,
                                    int   n_bytes)
{
  DBusString str;

  if (!_dbus_string_init (&str))
542
    {
543
      _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes);
544 545
      return;
    }
546 547 548 549

  if (!_dbus_generate_random_bytes (&str, n_bytes))
    {
      _dbus_string_free (&str);
550
      _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes);
551
      return;
552 553 554 555 556
    }

  _dbus_string_copy_to_buffer (&str, buffer, n_bytes);

  _dbus_string_free (&str);
557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
}

/**
 * Generates the given number of random bytes, where the bytes are
 * chosen from the alphanumeric ASCII subset.
 *
 * @param str the string
 * @param n_bytes the number of random ASCII bytes to append to string
 * @returns #TRUE on success, #FALSE if no memory or other failure
 */
dbus_bool_t
_dbus_generate_random_ascii (DBusString *str,
                             int         n_bytes)
{
  static const char letters[] =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
  int i;
  int len;
  
  if (!_dbus_generate_random_bytes (str, n_bytes))
    return FALSE;
  
  len = _dbus_string_get_length (str);
  i = len - n_bytes;
  while (i < len)
582
    {
583 584 585
      _dbus_string_set_byte (str, i,
                             letters[_dbus_string_get_byte (str, i) %
                                     (sizeof (letters) - 1)]);
586

587
      ++i;
588 589
    }

590 591 592 593
  _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes,
                                             n_bytes));

  return TRUE;
594
}
595

596
/**
597 598
 * Converts a UNIX errno, or Windows errno or WinSock error value into
 * a #DBusError name.
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616
 *
 * @todo should cover more errnos, specifically those
 * from open().
 * 
 * @param error_number the errno.
 * @returns an error name
 */
const char*
_dbus_error_from_errno (int error_number)
{
  switch (error_number)
    {
    case 0:
      return DBUS_ERROR_FAILED;
      
#ifdef EPROTONOSUPPORT
    case EPROTONOSUPPORT:
      return DBUS_ERROR_NOT_SUPPORTED;
617
#elif defined(WSAEPROTONOSUPPORT)
618 619 620
    case WSAEPROTONOSUPPORT:
      return DBUS_ERROR_NOT_SUPPORTED;
#endif
621 622 623
#ifdef EAFNOSUPPORT
    case EAFNOSUPPORT:
      return DBUS_ERROR_NOT_SUPPORTED;
624
#elif defined(WSAEAFNOSUPPORT)
625 626 627
    case WSAEAFNOSUPPORT:
      return DBUS_ERROR_NOT_SUPPORTED;
#endif
628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
#ifdef ENFILE
    case ENFILE:
      return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */
#endif
#ifdef EMFILE
    case EMFILE:
      return DBUS_ERROR_LIMITS_EXCEEDED;
#endif
#ifdef EACCES
    case EACCES:
      return DBUS_ERROR_ACCESS_DENIED;
#endif
#ifdef EPERM
    case EPERM:
      return DBUS_ERROR_ACCESS_DENIED;
#endif
#ifdef ENOBUFS
    case ENOBUFS:
      return DBUS_ERROR_NO_MEMORY;
#endif
#ifdef ENOMEM
    case ENOMEM:
      return DBUS_ERROR_NO_MEMORY;
#endif
#ifdef ECONNREFUSED
    case ECONNREFUSED:
      return DBUS_ERROR_NO_SERVER;
655
#elif defined(WSAECONNREFUSED)
656 657 658
    case WSAECONNREFUSED:
      return DBUS_ERROR_NO_SERVER;
#endif
659 660 661
#ifdef ETIMEDOUT
    case ETIMEDOUT:
      return DBUS_ERROR_TIMEOUT;
662
#elif defined(WSAETIMEDOUT)
663 664 665
    case WSAETIMEDOUT:
      return DBUS_ERROR_TIMEOUT;
#endif
666 667 668
#ifdef ENETUNREACH
    case ENETUNREACH:
      return DBUS_ERROR_NO_NETWORK;
669
#elif defined(WSAENETUNREACH)
670 671 672
    case WSAENETUNREACH:
      return DBUS_ERROR_NO_NETWORK;
#endif
673 674 675
#ifdef EADDRINUSE
    case EADDRINUSE:
      return DBUS_ERROR_ADDRESS_IN_USE;
676
#elif defined(WSAEADDRINUSE)
677 678 679
    case WSAEADDRINUSE:
      return DBUS_ERROR_ADDRESS_IN_USE;
#endif
680 681
#ifdef EEXIST
    case EEXIST:
682
      return DBUS_ERROR_FILE_EXISTS;
683 684 685 686 687 688 689 690 691 692
#endif
#ifdef ENOENT
    case ENOENT:
      return DBUS_ERROR_FILE_NOT_FOUND;
#endif
    }

  return DBUS_ERROR_FAILED;
}

693 694 695 696 697 698 699 700 701 702 703
/**
 * Converts the current system errno value into a #DBusError name.
 *
 * @returns an error name
 */
const char*
_dbus_error_from_system_errno (void)
{
  return _dbus_error_from_errno (errno);
}

704 705 706 707 708 709
/**
 * Assign 0 to the global errno variable
 */
void
_dbus_set_errno_to_zero (void)
{
710 711 712
#ifdef DBUS_WINCE
  SetLastError (0);
#else
713
  errno = 0;
714
#endif
715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746
}

/**
 * See if errno is set
 * @returns #TRUE if errno is not 0
 */
dbus_bool_t
_dbus_get_is_errno_nonzero (void)
{
  return errno != 0;
}

/**
 * See if errno is ENOMEM
 * @returns #TRUE if errno == ENOMEM
 */
dbus_bool_t
_dbus_get_is_errno_enomem (void)
{
  return errno == ENOMEM;
}

/**
 * See if errno is EINTR
 * @returns #TRUE if errno == EINTR
 */
dbus_bool_t
_dbus_get_is_errno_eintr (void)
{
  return errno == EINTR;
}

747 748 749 750 751 752 753 754 755 756
/**
 * See if errno is EPIPE
 * @returns #TRUE if errno == EPIPE
 */
dbus_bool_t
_dbus_get_is_errno_epipe (void)
{
  return errno == EPIPE;
}

757 758 759 760 761 762 763 764 765 766
/**
 * Get error message from errno
 * @returns _dbus_strerror(errno)
 */
const char*
_dbus_strerror_from_errno (void)
{
  return _dbus_strerror (errno);
}

767
/** @} end of sysdeps */
768 769

/* tests in dbus-sysdeps-util.c */