/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */ /* dbus-sysdeps.c Wrappers around system/libc features shared between UNIX and Windows (internal to D-Bus implementation) * * Copyright (C) 2002, 2003, 2006 Red Hat, Inc. * Copyright (C) 2003 CodeFactory AB * * Licensed under the Academic Free License version 2.1 * * 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 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * */ #include "dbus-internals.h" #include "dbus-sysdeps.h" #include "dbus-threads.h" #include "dbus-protocol.h" #include "dbus-string.h" #include "dbus-list.h" /* 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... */ #include #include #include #include /* This is UNIX-specific (on windows it's just in stdlib.h I believe) * but OK since the same stuff does exist on Windows in stdlib.h * and covered by a configure check. */ #ifdef HAVE_ERRNO_H #include #endif _DBUS_DEFINE_GLOBAL_LOCK (win_fds); _DBUS_DEFINE_GLOBAL_LOCK (sid_atom_cache); _DBUS_DEFINE_GLOBAL_LOCK (system_users); extern char **environ; /** * @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. * * @{ */ /** * Aborts the program with SIGABRT (dumping core). */ void _dbus_abort (void) { const char *s; _dbus_print_backtrace (); s = _dbus_getenv ("DBUS_BLOCK_ON_ABORT"); if (s && *s) { /* don't use _dbus_warn here since it can _dbus_abort() */ fprintf (stderr, " Process %lu sleeping for gdb attach\n", _dbus_pid_for_log ()); _dbus_sleep_milliseconds (1000 * 180); } abort (); _dbus_exit (1); /* in case someone manages to ignore SIGABRT ? */ } /** * Wrapper for setenv(). If the value is #NULL, unsets * the environment variable. * * 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. * * @param varname name of environment variable * @param value value of environment variable * @returns #TRUE on success. */ dbus_bool_t _dbus_setenv (const char *varname, const char *value) { _dbus_assert (varname != NULL); if (value == NULL) { #ifdef HAVE_UNSETENV unsetenv (varname); return TRUE; #else char *putenv_value; size_t len; len = strlen (varname); /* Use system malloc to avoid memleaks that dbus_malloc * will get upset about. */ putenv_value = malloc (len + 2); if (putenv_value == NULL) return FALSE; strcpy (putenv_value, varname); #if defined(DBUS_WIN) strcat (putenv_value, "="); #endif return (putenv (putenv_value) == 0); #endif } 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; varname_len = strlen (varname); value_len = strlen (value); len = varname_len + value_len + 1 /* '=' */ ; /* 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); #endif } } /** * 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); } /** * Wrapper for clearenv(). * * @returns #TRUE on success. */ dbus_bool_t _dbus_clearenv (void) { dbus_bool_t rc = TRUE; #ifdef HAVE_CLEARENV if (clearenv () != 0) rc = FALSE; #else if (environ != NULL) environ[0] = NULL; #endif return rc; } /** * Gets a #NULL-terminated list of key=value pairs from the * environment. Use dbus_free_string_array to free it. * * @returns the environment or #NULL on OOM */ char ** _dbus_get_environment (void) { int i, length; char **environment; _dbus_assert (environ != NULL); for (length = 0; environ[length] != NULL; length++); /* Add one for NULL */ length++; environment = dbus_new0 (char *, length); if (environment == NULL) return NULL; for (i = 0; environ[i] != NULL; i++) { environment[i] = _dbus_strdup (environ[i]); if (environment[i] == NULL) break; } if (environ[i] != NULL) { dbus_free_string_array (environment); environment = NULL; } return environment; } /* * init a pipe instance. * * @param pipe the pipe * @param fd the file descriptor to init from */ void _dbus_pipe_init (DBusPipe *pipe, int fd) { pipe->fd_or_handle = fd; } /** * init a pipe with stdout * * @param pipe the pipe */ void _dbus_pipe_init_stdout (DBusPipe *pipe) { _dbus_pipe_init (pipe, 1); } /** * check if a pipe is valid; pipes can be set invalid, similar to * a -1 file descriptor. * * @param pipe the pipe instance * @returns #FALSE if pipe is not valid */ dbus_bool_t _dbus_pipe_is_valid(DBusPipe *pipe) { return pipe->fd_or_handle >= 0; } /** * Check if a pipe is stdout or stderr. * * @param pipe the pipe instance * @returns #TRUE if pipe is one of the standard out/err channels */ dbus_bool_t _dbus_pipe_is_stdout_or_stderr (DBusPipe *pipe) { return pipe->fd_or_handle == 1 || pipe->fd_or_handle == 2; } /** * Initializes a pipe to an invalid value. * @param pipe the pipe */ void _dbus_pipe_invalidate (DBusPipe *pipe) { pipe->fd_or_handle = -1; } /** * Split paths into a list of char strings * * @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; DBusString file_suffix; 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; } /** @} */ /** * @addtogroup DBusString * * @{ */ /** * Appends an integer to a DBusString. * * @param str the string * @param value the integer value * @returns #FALSE if not enough memory or other failure. */ dbus_bool_t _dbus_string_append_int (DBusString *str, long value) { /* 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; orig_len = _dbus_string_get_length (str); if (!_dbus_string_lengthen (str, MAX_LONG_LEN)) return FALSE; buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN); snprintf (buf, MAX_LONG_LEN, "%ld", value); i = 0; while (*buf) { ++buf; ++i; } _dbus_string_shorten (str, MAX_LONG_LEN - i); return TRUE; } /** * Appends an unsigned integer to a DBusString. * * @param str the string * @param value the integer value * @returns #FALSE if not enough memory or other failure. */ dbus_bool_t _dbus_string_append_uint (DBusString *str, unsigned long value) { /* this is wrong, but definitely on the high side. */ #define MAX_ULONG_LEN (MAX_LONG_LEN * 2) int orig_len; int i; char *buf; orig_len = _dbus_string_get_length (str); if (!_dbus_string_lengthen (str, MAX_ULONG_LEN)) return FALSE; buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN); snprintf (buf, MAX_ULONG_LEN, "%lu", value); i = 0; while (*buf) { ++buf; ++i; } _dbus_string_shorten (str, MAX_ULONG_LEN - i); return TRUE; } #ifdef DBUS_BUILD_TESTS /** * Appends a double to a DBusString. * * @param str the string * @param value the floating point value * @returns #FALSE if not enough memory or other failure. */ dbus_bool_t _dbus_string_append_double (DBusString *str, double value) { #define MAX_DOUBLE_LEN 64 /* this is completely made up :-/ */ int orig_len; char *buf; int i; orig_len = _dbus_string_get_length (str); if (!_dbus_string_lengthen (str, MAX_DOUBLE_LEN)) return FALSE; buf = _dbus_string_get_data_len (str, orig_len, MAX_DOUBLE_LEN); snprintf (buf, MAX_LONG_LEN, "%g", value); i = 0; while (*buf) { ++buf; ++i; } _dbus_string_shorten (str, MAX_DOUBLE_LEN - i); return TRUE; } #endif /* DBUS_BUILD_TESTS */ /** * 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. * * @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 */ dbus_bool_t _dbus_string_parse_int (const DBusString *str, int start, long *value_return, int *end_return) { long v; const char *p; char *end; p = _dbus_string_get_const_data_len (str, start, _dbus_string_get_length (str) - start); end = NULL; errno = 0; v = strtol (p, &end, 0); if (end == NULL || end == p || errno != 0) return FALSE; if (value_return) *value_return = v; if (end_return) *end_return = start + (end - p); return TRUE; } /** * 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. * * @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 */ dbus_bool_t _dbus_string_parse_uint (const DBusString *str, int start, unsigned long *value_return, int *end_return) { unsigned long v; const char *p; char *end; p = _dbus_string_get_const_data_len (str, start, _dbus_string_get_length (str) - start); end = NULL; errno = 0; v = strtoul (p, &end, 0); if (end == NULL || end == p || errno != 0) return FALSE; if (value_return) *value_return = v; if (end_return) *end_return = start + (end - p); return TRUE; } #ifdef DBUS_BUILD_TESTS static dbus_bool_t ascii_isspace (char c) { return (c == ' ' || c == '\f' || c == '\n' || c == '\r' || c == '\t' || c == '\v'); } #endif /* DBUS_BUILD_TESTS */ #ifdef DBUS_BUILD_TESTS static dbus_bool_t ascii_isdigit (char c) { return c >= '0' && c <= '9'; } #endif /* DBUS_BUILD_TESTS */ #ifdef DBUS_BUILD_TESTS static dbus_bool_t ascii_isxdigit (char c) { return (ascii_isdigit (c) || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')); } #endif /* DBUS_BUILD_TESTS */ #ifdef DBUS_BUILD_TESTS /* Calls strtod in a locale-independent fashion, by looking at * the locale data and patching the decimal comma to a point. * * Relicensed from glib. */ static double ascii_strtod (const char *nptr, char **endptr) { /* FIXME: The Win32 C library's strtod() doesn't handle hex. * Presumably many Unixes don't either. */ char *fail_pos; double val; struct lconv *locale_data; const char *decimal_point; int decimal_point_len; const char *p, *decimal_point_pos; const char *end = NULL; /* Silence gcc */ fail_pos = NULL; locale_data = localeconv (); decimal_point = locale_data->decimal_point; decimal_point_len = strlen (decimal_point); _dbus_assert (decimal_point_len != 0); decimal_point_pos = NULL; if (decimal_point[0] != '.' || decimal_point[1] != 0) { p = nptr; /* Skip leading space */ while (ascii_isspace (*p)) p++; /* Skip leading optional sign */ if (*p == '+' || *p == '-') p++; if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) { p += 2; /* HEX - find the (optional) decimal point */ while (ascii_isxdigit (*p)) p++; if (*p == '.') { decimal_point_pos = p++; while (ascii_isxdigit (*p)) p++; if (*p == 'p' || *p == 'P') p++; if (*p == '+' || *p == '-') p++; while (ascii_isdigit (*p)) p++; end = p; } } else { while (ascii_isdigit (*p)) p++; if (*p == '.') { decimal_point_pos = p++; while (ascii_isdigit (*p)) p++; if (*p == 'e' || *p == 'E') p++; if (*p == '+' || *p == '-') p++; while (ascii_isdigit (*p)) p++; end = p; } } /* For the other cases, we need not convert the decimal point */ } /* Set errno to zero, so that we can distinguish zero results and underflows */ errno = 0; if (decimal_point_pos) { char *copy, *c; /* We need to convert the '.' to the locale specific decimal point */ copy = dbus_malloc (end - nptr + 1 + decimal_point_len); c = copy; memcpy (c, nptr, decimal_point_pos - nptr); c += decimal_point_pos - nptr; memcpy (c, decimal_point, decimal_point_len); c += decimal_point_len; memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1)); c += end - (decimal_point_pos + 1); *c = 0; val = strtod (copy, &fail_pos); if (fail_pos) { if (fail_pos > decimal_point_pos) fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1); else fail_pos = (char *)nptr + (fail_pos - copy); } dbus_free (copy); } else val = strtod (nptr, &fail_pos); if (endptr) *endptr = fail_pos; return val; } #endif /* DBUS_BUILD_TESTS */ #ifdef DBUS_BUILD_TESTS /** * Parses a floating point number 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. * * @param str the string * @param start the byte index of the start of the float * @param value_return return location of the float value or #NULL * @param end_return return location of the end of the float, or #NULL * @returns #TRUE on success */ dbus_bool_t _dbus_string_parse_double (const DBusString *str, int start, double *value_return, int *end_return) { double v; const char *p; char *end; p = _dbus_string_get_const_data_len (str, start, _dbus_string_get_length (str) - start); /* parsing hex works on linux but isn't portable, so intercept it * here to get uniform behavior. */ if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) return FALSE; end = NULL; errno = 0; v = ascii_strtod (p, &end); if (end == NULL || end == p || errno != 0) return FALSE; if (value_return) *value_return = v; if (end_return) *end_return = start + (end - p); return TRUE; } #endif /* DBUS_BUILD_TESTS */ /** @} */ /* DBusString group */ /** * @addtogroup DBusInternalsUtils * @{ */ void _dbus_generate_pseudorandom_bytes_buffer (char *buffer, int n_bytes) { long tv_usec; 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; buffer[i] = b; ++i; } } /** * 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)) { _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes); return; } if (!_dbus_generate_random_bytes (&str, n_bytes)) { _dbus_string_free (&str); _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes); return; } _dbus_string_copy_to_buffer (&str, buffer, n_bytes); _dbus_string_free (&str); } /** * 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) { _dbus_string_set_byte (str, i, letters[_dbus_string_get_byte (str, i) % (sizeof (letters) - 1)]); ++i; } _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes, n_bytes)); return TRUE; } /** * Converts a UNIX or Windows errno * into a #DBusError name. * * @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; #endif #ifdef EAFNOSUPPORT case EAFNOSUPPORT: return DBUS_ERROR_NOT_SUPPORTED; #endif #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 EINVAL case EINVAL: return DBUS_ERROR_FAILED; #endif #ifdef EBADF case EBADF: return DBUS_ERROR_FAILED; #endif #ifdef EFAULT case EFAULT: return DBUS_ERROR_FAILED; #endif #ifdef ENOTSOCK case ENOTSOCK: return DBUS_ERROR_FAILED; #endif #ifdef EISCONN case EISCONN: return DBUS_ERROR_FAILED; #endif #ifdef ECONNREFUSED case ECONNREFUSED: return DBUS_ERROR_NO_SERVER; #endif #ifdef ETIMEDOUT case ETIMEDOUT: return DBUS_ERROR_TIMEOUT; #endif #ifdef ENETUNREACH case ENETUNREACH: return DBUS_ERROR_NO_NETWORK; #endif #ifdef EADDRINUSE case EADDRINUSE: return DBUS_ERROR_ADDRESS_IN_USE; #endif #ifdef EEXIST case EEXIST: return DBUS_ERROR_FILE_EXISTS; #endif #ifdef ENOENT case ENOENT: return DBUS_ERROR_FILE_NOT_FOUND; #endif } return DBUS_ERROR_FAILED; } /** * Assign 0 to the global errno variable */ void _dbus_set_errno_to_zero (void) { errno = 0; } /** * 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; } /** * See if errno is EPIPE * @returns #TRUE if errno == EPIPE */ dbus_bool_t _dbus_get_is_errno_epipe (void) { return errno == EPIPE; } /** * Get error message from errno * @returns _dbus_strerror(errno) */ const char* _dbus_strerror_from_errno (void) { return _dbus_strerror (errno); } /** @} end of sysdeps */ /* tests in dbus-sysdeps-util.c */