1 /* -*- mode: C; c-file-style: "gnu" -*- */ 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22 * 23 */ 24 25 #include "dbus-internals.h" 26 #include "dbus-sysdeps.h" 27 #include "dbus-threads.h" 28 #include "dbus-protocol.h" 29 #include "dbus-string.h" 30 31 /* NOTE: If you include any unix/windows-specific headers here, you are probably doing something 32 * wrong and should be putting some code in dbus-sysdeps-unix.c or dbus-sysdeps-win.c. 33 * 34 * These are the standard ANSI C headers... 35 */ 36 #include <locale.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <stdio.h> 40 41 /* This is UNIX-specific (on windows it's just in stdlib.h I believe) 42 * but OK since the same stuff does exist on Windows in stdlib.h 43 * and covered by a configure check. 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 52 /** 53 * @defgroup DBusSysdeps Internal system-dependent API 54 * @ingroup DBusInternals 55 * @brief Internal system-dependent API available on UNIX and Windows 56 * 57 * The system-dependent API has a dual purpose. First, it encapsulates 58 * all usage of operating system APIs for ease of auditing and to 59 * avoid cluttering the rest of the code with bizarre OS quirks and 60 * headers. Second, it abstracts different operating system APIs for 61 * portability. 62 * 63 * @{ 64 */ 65 66 /** 67 * Aborts the program with SIGABRT (dumping core). 68 */ 69 void 70 _dbus_abort (void) 71 { 72 const char *s; 73 74 _dbus_print_backtrace (); 75 76 s = _dbus_getenv ("DBUS_BLOCK_ON_ABORT"); 77 if (s && *s) 78 { 79 /* don't use _dbus_warn here since it can _dbus_abort() */ 80 fprintf (stderr, " Process %lu sleeping for gdb attach\n", (unsigned long) _dbus_getpid()); 81 _dbus_sleep_milliseconds (1000 * 180); 82 } 83 84 abort (); 85 _dbus_exit (1); /* in case someone manages to ignore SIGABRT ? */ 86 } 87 88 /** 89 * Wrapper for setenv(). If the value is #NULL, unsets 90 * the environment variable. 91 * 92 * There is an unfixable memleak in that it is unsafe to 93 * free memory malloced for use with setenv. This is because 94 * we can not rely on internal implementation details of 95 * the underlying libc library. 96 * 97 * @param varname name of environment variable 98 * @param value value of environment variable 99 * @returns #TRUE on success. 100 */ 101 dbus_bool_t 102 _dbus_setenv (const char *varname, 103 const char *value) 104 { 105 _dbus_assert (varname != NULL); 106 107 if (value == NULL) 108 { 109 #ifdef HAVE_UNSETENV 110 unsetenv (varname); 111 return TRUE; 112 #else 113 char *putenv_value; 114 size_t len; 115 116 len = strlen (varname); 117 118 /* Use system malloc to avoid memleaks that dbus_malloc 119 * will get upset about. 120 */ 121 122 putenv_value = malloc (len + 1); 123 if (putenv_value == NULL) 124 return FALSE; 125 126 strcpy (putenv_value, varname); 127 128 return (putenv (putenv_value) == 0); 129 #endif 130 } 131 else 132 { 133 #ifdef HAVE_SETENV 134 return (setenv (varname, value, TRUE) == 0); 135 #else 136 char *putenv_value; 137 size_t len; 138 size_t varname_len; 139 size_t value_len; 140 141 varname_len = strlen (varname); 142 value_len = strlen (value); 143 144 len = varname_len + value_len + 1 /* '=' */ ; 145 146 /* Use system malloc to avoid memleaks that dbus_malloc 147 * will get upset about. 148 */ 149 150 putenv_value = malloc (len + 1); 151 if (putenv_value == NULL) 152 return FALSE; 153 154 strcpy (putenv_value, varname); 155 strcpy (putenv_value + varname_len, "="); 156 strcpy (putenv_value + varname_len + 1, value); 157 158 return (putenv (putenv_value) == 0); 159 #endif 160 } 161 } 162 163 /** 164 * Wrapper for getenv(). 165 * 166 * @param varname name of environment variable 167 * @returns value of environment variable or #NULL if unset 168 */ 169 const char* 170 _dbus_getenv (const char *varname) 171 { 172 return getenv (varname); 173 } 174 175 /** @} */ 176 177 /** 178 * @addtogroup DBusString 179 * 180 * @{ 181 */ 182 /** 183 * Appends an integer to a DBusString. 184 * 185 * @param str the string 186 * @param value the integer value 187 * @returns #FALSE if not enough memory or other failure. 188 */ 189 dbus_bool_t 190 _dbus_string_append_int (DBusString *str, 191 long value) 192 { 193 /* this calculation is from comp.lang.c faq */ 194 #define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1) /* +1 for '-' */ 195 int orig_len; 196 int i; 197 char *buf; 198 199 orig_len = _dbus_string_get_length (str); 200 201 if (!_dbus_string_lengthen (str, MAX_LONG_LEN)) 202 return FALSE; 203 204 buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN); 205 206 snprintf (buf, MAX_LONG_LEN, "%ld", value); 207 208 i = 0; 209 while (*buf) 210 { 211 ++buf; 212 ++i; 213 } 214 215 _dbus_string_shorten (str, MAX_LONG_LEN - i); 216 217 return TRUE; 218 } 219 220 /** 221 * Appends an unsigned integer to a DBusString. 222 * 223 * @param str the string 224 * @param value the integer value 225 * @returns #FALSE if not enough memory or other failure. 226 */ 227 dbus_bool_t 228 _dbus_string_append_uint (DBusString *str, 229 unsigned long value) 230 { 231 /* this is wrong, but definitely on the high side. */ 232 #define MAX_ULONG_LEN (MAX_LONG_LEN * 2) 233 int orig_len; 234 int i; 235 char *buf; 236 237 orig_len = _dbus_string_get_length (str); 238 239 if (!_dbus_string_lengthen (str, MAX_ULONG_LEN)) 240 return FALSE; 241 242 buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN); 243 244 snprintf (buf, MAX_ULONG_LEN, "%lu", value); 245 246 i = 0; 247 while (*buf) 248 { 249 ++buf; 250 ++i; 251 } 252 253 _dbus_string_shorten (str, MAX_ULONG_LEN - i); 254 255 return TRUE; 256 } 257 258 #ifdef DBUS_BUILD_TESTS 259 /** 260 * Appends a double to a DBusString. 261 * 262 * @param str the string 263 * @param value the floating point value 264 * @returns #FALSE if not enough memory or other failure. 265 */ 266 dbus_bool_t 267 _dbus_string_append_double (DBusString *str, 268 double value) 269 { 270 #define MAX_DOUBLE_LEN 64 /* this is completely made up :-/ */ 271 int orig_len; 272 char *buf; 273 int i; 274 275 orig_len = _dbus_string_get_length (str); 276 277 if (!_dbus_string_lengthen (str, MAX_DOUBLE_LEN)) 278 return FALSE; 279 280 buf = _dbus_string_get_data_len (str, orig_len, MAX_DOUBLE_LEN); 281 282 snprintf (buf, MAX_LONG_LEN, "%g", value); 283 284 i = 0; 285 while (*buf) 286 { 287 ++buf; 288 ++i; 289 } 290 291 _dbus_string_shorten (str, MAX_DOUBLE_LEN - i); 292 293 return TRUE; 294 } 295 #endif /* DBUS_BUILD_TESTS */ 296 297 /** 298 * Parses an integer contained in a DBusString. Either return parameter 299 * may be #NULL if you aren't interested in it. The integer is parsed 300 * and stored in value_return. Return parameters are not initialized 301 * if the function returns #FALSE. 302 * 303 * @param str the string 304 * @param start the byte index of the start of the integer 305 * @param value_return return location of the integer value or #NULL 306 * @param end_return return location of the end of the integer, or #NULL 307 * @returns #TRUE on success 308 */ 309 dbus_bool_t 310 _dbus_string_parse_int (const DBusString *str, 311 int start, 312 long *value_return, 313 int *end_return) 314 { 315 long v; 316 const char *p; 317 char *end; 318 319 p = _dbus_string_get_const_data_len (str, start, 320 _dbus_string_get_length (str) - start); 321 322 end = NULL; 323 errno = 0; 324 v = strtol (p, &end, 0); 325 if (end == NULL || end == p || errno != 0) 326 return FALSE; 327 328 if (value_return) 329 *value_return = v; 330 if (end_return) 331 *end_return = start + (end - p); 332 333 return TRUE; 334 } 335 336 /** 337 * Parses an unsigned integer contained in a DBusString. Either return 338 * parameter may be #NULL if you aren't interested in it. The integer 339 * is parsed and stored in value_return. Return parameters are not 340 * initialized if the function returns #FALSE. 341 * 342 * @param str the string 343 * @param start the byte index of the start of the integer 344 * @param value_return return location of the integer value or #NULL 345 * @param end_return return location of the end of the integer, or #NULL 346 * @returns #TRUE on success 347 */ 348 dbus_bool_t 349 _dbus_string_parse_uint (const DBusString *str, 350 int start, 351 unsigned long *value_return, 352 int *end_return) 353 { 354 unsigned long v; 355 const char *p; 356 char *end; 357 358 p = _dbus_string_get_const_data_len (str, start, 359 _dbus_string_get_length (str) - start); 360 361 end = NULL; 362 errno = 0; 363 v = strtoul (p, &end, 0); 364 if (end == NULL || end == p || errno != 0) 365 return FALSE; 366 367 if (value_return) 368 *value_return = v; 369 if (end_return) 370 *end_return = start + (end - p); 371 372 return TRUE; 373 } 374 375 #ifdef DBUS_BUILD_TESTS 376 static dbus_bool_t 377 ascii_isspace (char c) 378 { 379 return (c == ' ' || 380 c == '\f' || 381 c == '\n' || 382 c == '\r' || 383 c == '\t' || 384 c == '\v'); 385 } 386 #endif /* DBUS_BUILD_TESTS */ 387 388 #ifdef DBUS_BUILD_TESTS 389 static dbus_bool_t 390 ascii_isdigit (char c) 391 { 392 return c >= '0' && c <= '9'; 393 } 394 #endif /* DBUS_BUILD_TESTS */ 395 396 #ifdef DBUS_BUILD_TESTS 397 static dbus_bool_t 398 ascii_isxdigit (char c) 399 { 400 return (ascii_isdigit (c) || 401 (c >= 'a' && c <= 'f') || 402 (c >= 'A' && c <= 'F')); 403 } 404 #endif /* DBUS_BUILD_TESTS */ 405 406 #ifdef DBUS_BUILD_TESTS 407 /* Calls strtod in a locale-independent fashion, by looking at 408 * the locale data and patching the decimal comma to a point. 409 * 410 * Relicensed from glib. 411 */ 412 static double 413 ascii_strtod (const char *nptr, 414 char **endptr) 415 { 416 char *fail_pos; 417 double val; 418 struct lconv *locale_data; 419 const char *decimal_point; 420 int decimal_point_len; 421 const char *p, *decimal_point_pos; 422 const char *end = NULL; /* Silence gcc */ 423 424 fail_pos = NULL; 425 426 locale_data = localeconv (); 427 decimal_point = locale_data->decimal_point; 428 decimal_point_len = strlen (decimal_point); 429 430 _dbus_assert (decimal_point_len != 0); 431 432 decimal_point_pos = NULL; 433 if (decimal_point[0] != '.' || 434 decimal_point[1] != 0) 435 { 436 p = nptr; 437 /* Skip leading space */ 438 while (ascii_isspace (*p)) 439 p++; 440 441 /* Skip leading optional sign */ 442 if (*p == '+' || *p == '-') 443 p++; 444 445 if (p[0] == '0' && 446 (p[1] == 'x' || p[1] == 'X')) 447 { 448 p += 2; 449 /* HEX - find the (optional) decimal point */ 450 451 while (ascii_isxdigit (*p)) 452 p++; 453 454 if (*p == '.') 455 { 456 decimal_point_pos = p++; 457 458 while (ascii_isxdigit (*p)) 459 p++; 460 461 if (*p == 'p' || *p == 'P') 462 p++; 463 if (*p == '+' || *p == '-') 464 p++; 465 while (ascii_isdigit (*p)) 466 p++; 467 end = p; 468 } 469 } 470 else 471 { 472 while (ascii_isdigit (*p)) 473 p++; 474 475 if (*p == '.') 476 { 477 decimal_point_pos = p++; 478 479 while (ascii_isdigit (*p)) 480 p++; 481 482 if (*p == 'e' || *p == 'E') 483 p++; 484 if (*p == '+' || *p == '-') 485 p++; 486 while (ascii_isdigit (*p)) 487 p++; 488 end = p; 489 } 490 } 491 /* For the other cases, we need not convert the decimal point */ 492 } 493 494 /* Set errno to zero, so that we can distinguish zero results 495 and underflows */ 496 errno = 0; 497 498 if (decimal_point_pos) 499 { 500 char *copy, *c; 501 502 /* We need to convert the '.' to the locale specific decimal point */ 503 copy = dbus_malloc (end - nptr + 1 + decimal_point_len); 504 505 c = copy; 506 memcpy (c, nptr, decimal_point_pos - nptr); 507 c += decimal_point_pos - nptr; 508 memcpy (c, decimal_point, decimal_point_len); 509 c += decimal_point_len; 510 memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1)); 511 c += end - (decimal_point_pos + 1); 512 *c = 0; 513 514 val = strtod (copy, &fail_pos); 515 516 if (fail_pos) 517 { 518 if (fail_pos > decimal_point_pos) 519 fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1); 520 else 521 fail_pos = (char *)nptr + (fail_pos - copy); 522 } 523 524 dbus_free (copy); 525 526 } 527 else 528 val = strtod (nptr, &fail_pos); 529 530 if (endptr) 531 *endptr = fail_pos; 532 533 return val; 534 } 535 #endif /* DBUS_BUILD_TESTS */ 536 537 #ifdef DBUS_BUILD_TESTS 538 /** 539 * Parses a floating point number contained in a DBusString. Either 540 * return parameter may be #NULL if you aren't interested in it. The 541 * integer is parsed and stored in value_return. Return parameters are 542 * not initialized if the function returns #FALSE. 543 * 544 * @param str the string 545 * @param start the byte index of the start of the float 546 * @param value_return return location of the float value or #NULL 547 * @param end_return return location of the end of the float, or #NULL 548 * @returns #TRUE on success 549 */ 550 dbus_bool_t 551 _dbus_string_parse_double (const DBusString *str, 552 int start, 553 double *value_return, 554 int *end_return) 555 { 556 double v; 557 const char *p; 558 char *end; 559 560 p = _dbus_string_get_const_data_len (str, start, 561 _dbus_string_get_length (str) - start); 562 563 end = NULL; 564 errno = 0; 565 v = ascii_strtod (p, &end); 566 if (end == NULL || end == p || errno != 0) 567 return FALSE; 568 569 if (value_return) 570 *value_return = v; 571 if (end_return) 572 *end_return = start + (end - p); 573 574 return TRUE; 575 } 576 #endif /* DBUS_BUILD_TESTS */ 577 578 /** @} */ /* DBusString group */ 579 580 /** 581 * @addtogroup DBusInternalsUtils 582 * @{ 583 */ 584 585 /** 586 * Frees the members of info 587 * (but not info itself) 588 * @param info the user info struct 589 */ 590 void 591 _dbus_user_info_free (DBusUserInfo *info) 592 { 593 dbus_free (info->group_ids); 594 dbus_free (info->username); 595 dbus_free (info->homedir); 596 } 597 598 /** 599 * Frees the members of info (but not info itself). 600 * 601 * @param info the group info 602 */ 603 void 604 _dbus_group_info_free (DBusGroupInfo *info) 605 { 606 dbus_free (info->groupname); 607 } 608 609 /** 610 * Sets fields in DBusCredentials to DBUS_PID_UNSET, 611 * DBUS_UID_UNSET, DBUS_GID_UNSET. 612 * 613 * @param credentials the credentials object to fill in 614 */ 615 void 616 _dbus_credentials_clear (DBusCredentials *credentials) 617 { 618 credentials->pid = DBUS_PID_UNSET; 619 credentials->uid = DBUS_UID_UNSET; 620 credentials->gid = DBUS_GID_UNSET; 621 } 622 623 /** 624 * Checks whether the provided_credentials are allowed to log in 625 * as the expected_credentials. 626 * 627 * @param expected_credentials credentials we're trying to log in as 628 * @param provided_credentials credentials we have 629 * @returns #TRUE if we can log in 630 */ 631 dbus_bool_t 632 _dbus_credentials_match (const DBusCredentials *expected_credentials, 633 const DBusCredentials *provided_credentials) 634 { 635 if (provided_credentials->uid == DBUS_UID_UNSET) 636 return FALSE; 637 else if (expected_credentials->uid == DBUS_UID_UNSET) 638 return FALSE; 639 else if (provided_credentials->uid == 0) 640 return TRUE; 641 else if (provided_credentials->uid == expected_credentials->uid) 642 return TRUE; 643 else 644 return FALSE; 645 } 646 647 _DBUS_DEFINE_GLOBAL_LOCK (atomic); 648 649 #ifdef DBUS_USE_ATOMIC_INT_486 650 /* Taken from CVS version 1.7 of glibc's sysdeps/i386/i486/atomicity.h */ 651 /* Since the asm stuff here is gcc-specific we go ahead and use "inline" also */ 652 static inline dbus_int32_t 653 atomic_exchange_and_add (DBusAtomic *atomic, 654 volatile dbus_int32_t val) 655 { 656 register dbus_int32_t result; 657 658 __asm__ __volatile__ ("lock; xaddl %0,%1" 659 : "=r" (result), "=m" (atomic->value) 660 : "0" (val), "m" (atomic->value)); 661 return result; 662 } 663 #endif 664 665 /** 666 * Atomically increments an integer 667 * 668 * @param atomic pointer to the integer to increment 669 * @returns the value before incrementing 670 * 671 * @todo implement arch-specific faster atomic ops 672 */ 673 dbus_int32_t 674 _dbus_atomic_inc (DBusAtomic *atomic) 675 { 676 #ifdef DBUS_USE_ATOMIC_INT_486 677 return atomic_exchange_and_add (atomic, 1); 678 #else 679 dbus_int32_t res; 680 _DBUS_LOCK (atomic); 681 res = atomic->value; 682 atomic->value += 1; 683 _DBUS_UNLOCK (atomic); 684 return res; 685 #endif 686 } 687 688 /** 689 * Atomically decrement an integer 690 * 691 * @param atomic pointer to the integer to decrement 692 * @returns the value before decrementing 693 * 694 * @todo implement arch-specific faster atomic ops 695 */ 696 dbus_int32_t 697 _dbus_atomic_dec (DBusAtomic *atomic) 698 { 699 #ifdef DBUS_USE_ATOMIC_INT_486 700 return atomic_exchange_and_add (atomic, -1); 701 #else 702 dbus_int32_t res; 703 704 _DBUS_LOCK (atomic); 705 res = atomic->value; 706 atomic->value -= 1; 707 _DBUS_UNLOCK (atomic); 708 return res; 709 #endif 710 } 711 712 void 713 _dbus_generate_pseudorandom_bytes_buffer (char *buffer, 714 int n_bytes) 715 { 716 long tv_usec; 717 int i; 718 719 /* fall back to pseudorandom */ 720 _dbus_verbose ("Falling back to pseudorandom for %d bytes\n", 721 n_bytes); 722 723 _dbus_get_current_time (NULL, &tv_usec); 724 srand (tv_usec); 725 726 i = 0; 727 while (i < n_bytes) 728 { 729 double r; 730 unsigned int b; 731 732 r = rand (); 733 b = (r / (double) RAND_MAX) * 255.0; 734 735 buffer[i] = b; 736 737 ++i; 738 } 739 } 740 741 /** 742 * Fills n_bytes of the given buffer with random bytes. 743 * 744 * @param buffer an allocated buffer 745 * @param n_bytes the number of bytes in buffer to write to 746 */ 747 void 748 _dbus_generate_random_bytes_buffer (char *buffer, 749 int n_bytes) 750 { 751 DBusString str; 752 753 if (!_dbus_string_init (&str)) 754 { 755 _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes); 756 return; 757 } 758 759 if (!_dbus_generate_random_bytes (&str, n_bytes)) 760 { 761 _dbus_string_free (&str); 762 _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes); 763 return; 764 } 765 766 _dbus_string_copy_to_buffer (&str, buffer, n_bytes); 767 768 _dbus_string_free (&str); 769 } 770 771 /** 772 * Generates the given number of random bytes, where the bytes are 773 * chosen from the alphanumeric ASCII subset. 774 * 775 * @param str the string 776 * @param n_bytes the number of random ASCII bytes to append to string 777 * @returns #TRUE on success, #FALSE if no memory or other failure 778 */ 779 dbus_bool_t 780 _dbus_generate_random_ascii (DBusString *str, 781 int n_bytes) 782 { 783 static const char letters[] = 784 "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz"; 785 int i; 786 int len; 787 788 if (!_dbus_generate_random_bytes (str, n_bytes)) 789 return FALSE; 790 791 len = _dbus_string_get_length (str); 792 i = len - n_bytes; 793 while (i < len) 794 { 795 _dbus_string_set_byte (str, i, 796 letters[_dbus_string_get_byte (str, i) % 797 (sizeof (letters) - 1)]); 798 799 ++i; 800 } 801 802 _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes, 803 n_bytes)); 804 805 return TRUE; 806 } 807 808 /** 809 * Gets a UID from a UID string. 810 * 811 * @param uid_str the UID in string form 812 * @param uid UID to fill in 813 * @returns #TRUE if successfully filled in UID 814 */ 815 dbus_bool_t 816 _dbus_parse_uid (const DBusString *uid_str, 817 dbus_uid_t *uid) 818 { 819 int end; 820 long val; 821 822 if (_dbus_string_get_length (uid_str) == 0) 823 { 824 _dbus_verbose ("UID string was zero length\n"); 825 return FALSE; 826 } 827 828 val = -1; 829 end = 0; 830 if (!_dbus_string_parse_int (uid_str, 0, &val, 831 &end)) 832 { 833 _dbus_verbose ("could not parse string as a UID\n"); 834 return FALSE; 835 } 836 837 if (end != _dbus_string_get_length (uid_str)) 838 { 839 _dbus_verbose ("string contained trailing stuff after UID\n"); 840 return FALSE; 841 } 842 843 *uid = val; 844 845 return TRUE; 846 } 847 848 /** 849 * Converts a UNIX or Windows errno 850 * into a #DBusError name. 851 * 852 * @todo should cover more errnos, specifically those 853 * from open(). 854 * 855 * @param error_number the errno. 856 * @returns an error name 857 */ 858 const char* 859 _dbus_error_from_errno (int error_number) 860 { 861 switch (error_number) 862 { 863 case 0: 864 return DBUS_ERROR_FAILED; 865 866 #ifdef EPROTONOSUPPORT 867 case EPROTONOSUPPORT: 868 return DBUS_ERROR_NOT_SUPPORTED; 869 #endif 870 #ifdef EAFNOSUPPORT 871 case EAFNOSUPPORT: 872 return DBUS_ERROR_NOT_SUPPORTED; 873 #endif 874 #ifdef ENFILE 875 case ENFILE: 876 return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */ 877 #endif 878 #ifdef EMFILE 879 case EMFILE: 880 return DBUS_ERROR_LIMITS_EXCEEDED; 881 #endif 882 #ifdef EACCES 883 case EACCES: 884 return DBUS_ERROR_ACCESS_DENIED; 885 #endif 886 #ifdef EPERM 887 case EPERM: 888 return DBUS_ERROR_ACCESS_DENIED; 889 #endif 890 #ifdef ENOBUFS 891 case ENOBUFS: 892 return DBUS_ERROR_NO_MEMORY; 893 #endif 894 #ifdef ENOMEM 895 case ENOMEM: 896 return DBUS_ERROR_NO_MEMORY; 897 #endif 898 #ifdef EINVAL 899 case EINVAL: 900 return DBUS_ERROR_FAILED; 901 #endif 902 #ifdef EBADF 903 case EBADF: 904 return DBUS_ERROR_FAILED; 905 #endif 906 #ifdef EFAULT 907 case EFAULT: 908 return DBUS_ERROR_FAILED; 909 #endif 910 #ifdef ENOTSOCK 911 case ENOTSOCK: 912 return DBUS_ERROR_FAILED; 913 #endif 914 #ifdef EISCONN 915 case EISCONN: 916 return DBUS_ERROR_FAILED; 917 #endif 918 #ifdef ECONNREFUSED 919 case ECONNREFUSED: 920 return DBUS_ERROR_NO_SERVER; 921 #endif 922 #ifdef ETIMEDOUT 923 case ETIMEDOUT: 924 return DBUS_ERROR_TIMEOUT; 925 #endif 926 #ifdef ENETUNREACH 927 case ENETUNREACH: 928 return DBUS_ERROR_NO_NETWORK; 929 #endif 930 #ifdef EADDRINUSE 931 case EADDRINUSE: 932 return DBUS_ERROR_ADDRESS_IN_USE; 933 #endif 934 #ifdef EEXIST 935 case EEXIST: 936 return DBUS_ERROR_FILE_EXISTS; 937 #endif 938 #ifdef ENOENT 939 case ENOENT: 940 return DBUS_ERROR_FILE_NOT_FOUND; 941 #endif 942 } 943 944 return DBUS_ERROR_FAILED; 945 } 946 947 /** @} end of sysdeps */ 948 949 /* tests in dbus-sysdeps-util.c */ 950
