D-Bus  1.10.24
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 #include "dbus-misc.h"
33 
34 /* NOTE: If you include any unix/windows-specific headers here, you are probably doing something
35  * wrong and should be putting some code in dbus-sysdeps-unix.c or dbus-sysdeps-win.c.
36  *
37  * These are the standard ANSI C headers...
38  */
39 #if HAVE_LOCALE_H
40 #include <locale.h>
41 #endif
42 #include <stdlib.h>
43 #include <string.h>
44 #include <stdio.h>
45 
46 #ifdef HAVE_ERRNO_H
47 #include <errno.h>
48 #endif
49 
50 #ifdef DBUS_WIN
51  #include <stdlib.h>
52 #elif (defined __APPLE__)
53 # include <crt_externs.h>
54 # define environ (*_NSGetEnviron())
55 #else
56 extern char **environ;
57 #endif
58 
76 void
78 {
79  const char *s;
80 
82 
83  s = _dbus_getenv ("DBUS_BLOCK_ON_ABORT");
84  if (s && *s)
85  {
86  /* don't use _dbus_warn here since it can _dbus_abort() */
87  fprintf (stderr, " Process %lu sleeping for gdb attach\n", _dbus_pid_for_log ());
88  _dbus_sleep_milliseconds (1000 * 180);
89  }
90 
91  abort ();
92  _dbus_exit (1); /* in case someone manages to ignore SIGABRT ? */
93 }
94 
114 dbus_setenv (const char *varname,
115  const char *value)
116 {
117  _dbus_assert (varname != NULL);
118 
119  if (value == NULL)
120  {
121 #ifdef HAVE_UNSETENV
122  unsetenv (varname);
123  return TRUE;
124 #else
125  char *putenv_value;
126  size_t len;
127 
128  len = strlen (varname);
129 
130  /* Use system malloc to avoid memleaks that dbus_malloc
131  * will get upset about.
132  */
133 
134  putenv_value = malloc (len + 2);
135  if (putenv_value == NULL)
136  return FALSE;
137 
138  strcpy (putenv_value, varname);
139 #if defined(DBUS_WIN)
140  strcat (putenv_value, "=");
141 #endif
142 
143  return (putenv (putenv_value) == 0);
144 #endif
145  }
146  else
147  {
148 #ifdef HAVE_SETENV
149  return (setenv (varname, value, TRUE) == 0);
150 #else
151  char *putenv_value;
152  size_t len;
153  size_t varname_len;
154  size_t value_len;
155 
156  varname_len = strlen (varname);
157  value_len = strlen (value);
158 
159  len = varname_len + value_len + 1 /* '=' */ ;
160 
161  /* Use system malloc to avoid memleaks that dbus_malloc
162  * will get upset about.
163  */
164 
165  putenv_value = malloc (len + 1);
166  if (putenv_value == NULL)
167  return FALSE;
168 
169  strcpy (putenv_value, varname);
170  strcpy (putenv_value + varname_len, "=");
171  strcpy (putenv_value + varname_len + 1, value);
172 
173  return (putenv (putenv_value) == 0);
174 #endif
175  }
176 }
177 
184 const char*
185 _dbus_getenv (const char *varname)
186 {
187  /* Don't respect any environment variables if the current process is
188  * setuid. This is the equivalent of glibc's __secure_getenv().
189  */
190  if (_dbus_check_setuid ())
191  return NULL;
192  return getenv (varname);
193 }
194 
202 {
203  dbus_bool_t rc = TRUE;
204 
205 #ifdef HAVE_CLEARENV
206  if (clearenv () != 0)
207  rc = FALSE;
208 #else
209 
210  if (environ != NULL)
211  environ[0] = NULL;
212 #endif
213 
214  return rc;
215 }
216 
227  const char *suffix,
228  DBusList **dir_list)
229 {
230  int start;
231  int i;
232  int len;
233  char *cpath;
234  DBusString file_suffix;
235 
236  start = 0;
237  i = 0;
238 
239  _dbus_string_init_const (&file_suffix, suffix);
240 
241  len = _dbus_string_get_length (dirs);
242 
243  while (_dbus_string_find (dirs, start, _DBUS_PATH_SEPARATOR, &i))
244  {
245  DBusString path;
246 
247  if (!_dbus_string_init (&path))
248  goto oom;
249 
250  if (!_dbus_string_copy_len (dirs,
251  start,
252  i - start,
253  &path,
254  0))
255  {
256  _dbus_string_free (&path);
257  goto oom;
258  }
259 
260  _dbus_string_chop_white (&path);
261 
262  /* check for an empty path */
263  if (_dbus_string_get_length (&path) == 0)
264  goto next;
265 
266  if (!_dbus_concat_dir_and_file (&path,
267  &file_suffix))
268  {
269  _dbus_string_free (&path);
270  goto oom;
271  }
272 
273  if (!_dbus_string_copy_data(&path, &cpath))
274  {
275  _dbus_string_free (&path);
276  goto oom;
277  }
278 
279  if (!_dbus_list_append (dir_list, cpath))
280  {
281  _dbus_string_free (&path);
282  dbus_free (cpath);
283  goto oom;
284  }
285 
286  next:
287  _dbus_string_free (&path);
288  start = i + 1;
289  }
290 
291  if (start != len)
292  {
293  DBusString path;
294 
295  if (!_dbus_string_init (&path))
296  goto oom;
297 
298  if (!_dbus_string_copy_len (dirs,
299  start,
300  len - start,
301  &path,
302  0))
303  {
304  _dbus_string_free (&path);
305  goto oom;
306  }
307 
308  if (!_dbus_concat_dir_and_file (&path,
309  &file_suffix))
310  {
311  _dbus_string_free (&path);
312  goto oom;
313  }
314 
315  if (!_dbus_string_copy_data(&path, &cpath))
316  {
317  _dbus_string_free (&path);
318  goto oom;
319  }
320 
321  if (!_dbus_list_append (dir_list, cpath))
322  {
323  _dbus_string_free (&path);
324  dbus_free (cpath);
325  goto oom;
326  }
327 
328  _dbus_string_free (&path);
329  }
330 
331  return TRUE;
332 
333  oom:
335  _dbus_list_clear (dir_list);
336  return FALSE;
337 }
338 
355  long value)
356 {
357  /* this calculation is from comp.lang.c faq */
358 #define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1) /* +1 for '-' */
359  int orig_len;
360  int i;
361  char *buf;
362 
363  orig_len = _dbus_string_get_length (str);
364 
365  if (!_dbus_string_lengthen (str, MAX_LONG_LEN))
366  return FALSE;
367 
368  buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);
369 
370  snprintf (buf, MAX_LONG_LEN, "%ld", value);
371 
372  i = 0;
373  while (*buf)
374  {
375  ++buf;
376  ++i;
377  }
378 
379  _dbus_string_shorten (str, MAX_LONG_LEN - i);
380 
381  return TRUE;
382 }
383 
393  unsigned long value)
394 {
395  /* this is wrong, but definitely on the high side. */
396 #define MAX_ULONG_LEN (MAX_LONG_LEN * 2)
397  int orig_len;
398  int i;
399  char *buf;
400 
401  orig_len = _dbus_string_get_length (str);
402 
403  if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))
404  return FALSE;
405 
406  buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);
407 
408  snprintf (buf, MAX_ULONG_LEN, "%lu", value);
409 
410  i = 0;
411  while (*buf)
412  {
413  ++buf;
414  ++i;
415  }
416 
417  _dbus_string_shorten (str, MAX_ULONG_LEN - i);
418 
419  return TRUE;
420 }
421 
436  int start,
437  long *value_return,
438  int *end_return)
439 {
440  long v;
441  const char *p;
442  char *end;
443 
444  p = _dbus_string_get_const_data_len (str, start,
445  _dbus_string_get_length (str) - start);
446 
447  end = NULL;
449  v = strtol (p, &end, 0);
450  if (end == NULL || end == p || errno != 0)
451  return FALSE;
452 
453  if (value_return)
454  *value_return = v;
455  if (end_return)
456  *end_return = start + (end - p);
457 
458  return TRUE;
459 }
460 
475  int start,
476  unsigned long *value_return,
477  int *end_return)
478 {
479  unsigned long v;
480  const char *p;
481  char *end;
482 
483  p = _dbus_string_get_const_data_len (str, start,
484  _dbus_string_get_length (str) - start);
485 
486  end = NULL;
488  v = strtoul (p, &end, 0);
489  if (end == NULL || end == p || errno != 0)
490  return FALSE;
491 
492  if (value_return)
493  *value_return = v;
494  if (end_return)
495  *end_return = start + (end - p);
496 
497  return TRUE;
498 }
499  /* DBusString group */
501 
517  int n_bytes,
518  DBusError *error)
519 {
520  DBusString str;
521 
522  if (!_dbus_string_init (&str))
523  {
524  _DBUS_SET_OOM (error);
525  return FALSE;
526  }
527 
528  if (!_dbus_generate_random_bytes (&str, n_bytes, error))
529  {
530  _dbus_string_free (&str);
531  return FALSE;
532  }
533 
534  _dbus_string_copy_to_buffer (&str, buffer, n_bytes);
535 
536  _dbus_string_free (&str);
537  return TRUE;
538 }
539 
551  int n_bytes,
552  DBusError *error)
553 {
554  static const char letters[] =
555  "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
556  int i;
557  int len;
558 
559  if (!_dbus_generate_random_bytes (str, n_bytes, error))
560  return FALSE;
561 
562  len = _dbus_string_get_length (str);
563  i = len - n_bytes;
564  while (i < len)
565  {
566  _dbus_string_set_byte (str, i,
567  letters[_dbus_string_get_byte (str, i) %
568  (sizeof (letters) - 1)]);
569 
570  ++i;
571  }
572 
573  _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes,
574  n_bytes));
575 
576  return TRUE;
577 }
578 
589 const char*
590 _dbus_error_from_errno (int error_number)
591 {
592  switch (error_number)
593  {
594  case 0:
595  return DBUS_ERROR_FAILED;
596 
597 #ifdef EPROTONOSUPPORT
598  case EPROTONOSUPPORT:
600 #elif defined(WSAEPROTONOSUPPORT)
601  case WSAEPROTONOSUPPORT:
603 #endif
604 #ifdef EAFNOSUPPORT
605  case EAFNOSUPPORT:
607 #elif defined(WSAEAFNOSUPPORT)
608  case WSAEAFNOSUPPORT:
610 #endif
611 #ifdef ENFILE
612  case ENFILE:
613  return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */
614 #endif
615 #ifdef EMFILE
616  case EMFILE:
618 #endif
619 #ifdef EACCES
620  case EACCES:
622 #endif
623 #ifdef EPERM
624  case EPERM:
626 #endif
627 #ifdef ENOBUFS
628  case ENOBUFS:
629  return DBUS_ERROR_NO_MEMORY;
630 #endif
631 #ifdef ENOMEM
632  case ENOMEM:
633  return DBUS_ERROR_NO_MEMORY;
634 #endif
635 #ifdef ECONNREFUSED
636  case ECONNREFUSED:
637  return DBUS_ERROR_NO_SERVER;
638 #elif defined(WSAECONNREFUSED)
639  case WSAECONNREFUSED:
640  return DBUS_ERROR_NO_SERVER;
641 #endif
642 #ifdef ETIMEDOUT
643  case ETIMEDOUT:
644  return DBUS_ERROR_TIMEOUT;
645 #elif defined(WSAETIMEDOUT)
646  case WSAETIMEDOUT:
647  return DBUS_ERROR_TIMEOUT;
648 #endif
649 #ifdef ENETUNREACH
650  case ENETUNREACH:
651  return DBUS_ERROR_NO_NETWORK;
652 #elif defined(WSAENETUNREACH)
653  case WSAENETUNREACH:
654  return DBUS_ERROR_NO_NETWORK;
655 #endif
656 #ifdef EADDRINUSE
657  case EADDRINUSE:
659 #elif defined(WSAEADDRINUSE)
660  case WSAEADDRINUSE:
662 #endif
663 #ifdef EEXIST
664  case EEXIST:
665  return DBUS_ERROR_FILE_EXISTS;
666 #endif
667 #ifdef ENOENT
668  case ENOENT:
670 #endif
671  }
672 
673  return DBUS_ERROR_FAILED;
674 }
675 
681 const char*
683 {
684  return _dbus_error_from_errno (errno);
685 }
686 
690 void
692 {
693 #ifdef DBUS_WINCE
694  SetLastError (0);
695 #else
696  errno = 0;
697 #endif
698 }
699 
706 {
707  return e == ENOMEM;
708 }
709 
716 {
717  return e == EINTR;
718 }
719 
726 {
727  return e == EPIPE;
728 }
729 
736 {
737 #ifdef ETOOMANYREFS
738  return e == ETOOMANYREFS;
739 #else
740  return FALSE;
741 #endif
742 }
743 
748 const char*
750 {
751  return _dbus_strerror (errno);
752 }
753 
756 /* tests in dbus-sysdeps-util.c */
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_parse_int(const DBusString *str, int start, long *value_return, int *end_return)
Parses an integer contained in a DBusString.
Definition: dbus-sysdeps.c:435
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
Definition: dbus-string.c:697
#define DBUS_ERROR_FILE_NOT_FOUND
Missing file.
#define DBUS_ERROR_FILE_EXISTS
Existing file and the operation you&#39;re using does not silently overwrite.
dbus_bool_t _dbus_split_paths_and_append(DBusString *dirs, const char *suffix, DBusList **dir_list)
Split paths into a list of char strings.
Definition: dbus-sysdeps.c:226
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_append_uint(DBusString *str, unsigned long value)
Appends an unsigned integer to a DBusString.
Definition: dbus-sysdeps.c:392
#define NULL
A null pointer, defined appropriately for C or C++.
#define DBUS_ERROR_TIMEOUT
Certain timeout errors, possibly ETIMEDOUT on a socket.
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
Definition: dbus-string.c:760
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
Definition: dbus-memory.c:701
#define DBUS_ERROR_NOT_SUPPORTED
Requested operation isn&#39;t supported (like ENOSYS on UNIX).
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_append_int(DBusString *str, long value)
Appends an integer to a DBusString.
Definition: dbus-sysdeps.c:354
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
Definition: dbus-string.c:1989
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
dbus_bool_t _dbus_check_setuid(void)
NOTE: If you modify this function, please also consider making the corresponding change in GLib...
dbus_bool_t _dbus_concat_dir_and_file(DBusString *dir, const DBusString *next_component)
Appends the given filename to the given directory.
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
Definition: dbus-string.c:490
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
Definition: dbus-string.c:175
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
Definition: dbus-string.c:780
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
Definition: dbus-string.c:1604
dbus_bool_t _dbus_get_is_errno_etoomanyrefs(int e)
See if errno is ETOOMANYREFS.
Definition: dbus-sysdeps.c:735
void _dbus_abort(void)
Aborts the program with SIGABRT (dumping core).
Definition: dbus-sysdeps.c:77
const char * _dbus_error_from_errno(int error_number)
Converts a UNIX errno, or Windows errno or WinSock error value into a DBusError name.
Definition: dbus-sysdeps.c:590
dbus_bool_t _dbus_clearenv(void)
Wrapper for clearenv().
Definition: dbus-sysdeps.c:201
#define DBUS_ERROR_NO_SERVER
Unable to connect to server (probably caused by ECONNREFUSED on a socket).
dbus_bool_t _dbus_get_is_errno_epipe(int e)
See if errno is EPIPE.
Definition: dbus-sysdeps.c:725
dbus_bool_t _dbus_string_copy_data(const DBusString *str, char **data_return)
Copies the data from the string into a char*.
Definition: dbus-string.c:672
DBUS_EXPORT dbus_bool_t dbus_setenv(const char *variable, const char *value)
Wrapper for setenv().
Definition: dbus-sysdeps.c:114
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
Definition: dbus-types.h:35
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
Definition: dbus-string.c:190
dbus_bool_t _dbus_generate_random_ascii(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of random bytes, where the bytes are chosen from the alphanumeric ASCII su...
Definition: dbus-sysdeps.c:550
dbus_bool_t _dbus_list_append(DBusList **list, void *data)
Appends a value to the list.
Definition: dbus-list.c:270
void _dbus_list_foreach(DBusList **list, DBusForeachFunction function, void *data)
Calls the given function for each element in the list.
Definition: dbus-list.c:759
dbus_bool_t _dbus_get_is_errno_eintr(int e)
See if errno is EINTR.
Definition: dbus-sysdeps.c:715
Object representing an exception.
Definition: dbus-errors.h:48
#define DBUS_ERROR_ADDRESS_IN_USE
Can&#39;t bind a socket since its address is in use (i.e.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init().
Definition: dbus-string.c:259
#define TRUE
Expands to &quot;1&quot;.
#define DBUS_ERROR_FAILED
A generic error; &quot;something went wrong&quot; - see the error message for more.
void _dbus_exit(int code)
Exit the process, returning the given value.
const char * _dbus_strerror_from_errno(void)
Get error message from errno.
Definition: dbus-sysdeps.c:749
const char * _dbus_error_from_system_errno(void)
Converts the current system errno value into a DBusError name.
Definition: dbus-sysdeps.c:682
unsigned long _dbus_pid_for_log(void)
The only reason this is separate from _dbus_getpid() is to allow it on Windows for logging but not fo...
A node in a linked list.
Definition: dbus-list.h:34
DBUS_PRIVATE_EXPORT dbus_bool_t _dbus_string_parse_uint(const DBusString *str, int start, unsigned long *value_return, int *end_return)
Parses an unsigned integer contained in a DBusString.
Definition: dbus-sysdeps.c:474
#define DBUS_ERROR_ACCESS_DENIED
Security restrictions don&#39;t allow doing what you&#39;re trying to do.
dbus_bool_t _dbus_generate_random_bytes(DBusString *str, int n_bytes, DBusError *error)
Generates the given number of securely random bytes, using the best mechanism we can come up with...
#define DBUS_ERROR_NO_MEMORY
There was not enough memory to complete an operation.
void(* DBusForeachFunction)(void *element, void *data)
Used to iterate over each item in a collection, such as a DBusList.
#define FALSE
Expands to &quot;0&quot;.
void _dbus_print_backtrace(void)
On GNU libc systems, print a crude backtrace to stderr.
dbus_bool_t _dbus_generate_random_bytes_buffer(char *buffer, int n_bytes, DBusError *error)
Fills n_bytes of the given buffer with random bytes.
Definition: dbus-sysdeps.c:516
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string.
Definition: dbus-string.c:1375
void _dbus_sleep_milliseconds(int milliseconds)
Sleeps the given number of milliseconds.
const char * _dbus_getenv(const char *varname)
Wrapper for getenv().
Definition: dbus-sysdeps.c:185
#define DBUS_ERROR_NO_NETWORK
No network access (probably ENETUNREACH on a socket).
void _dbus_set_errno_to_zero(void)
Assign 0 to the global errno variable.
Definition: dbus-sysdeps.c:691
#define DBUS_ERROR_LIMITS_EXCEEDED
Some limited resource is exhausted.
dbus_bool_t _dbus_string_validate_ascii(const DBusString *str, int start, int len)
Checks that the given range of the string is valid ASCII with no nul bytes.
Definition: dbus-string.c:2450
dbus_bool_t _dbus_get_is_errno_enomem(int e)
See if errno is ENOMEM.
Definition: dbus-sysdeps.c:705
void _dbus_list_clear(DBusList **list)
Frees all links in the list and sets the list head to NULL.
Definition: dbus-list.c:542