Merge branch 'dbus-1.2'
[platform/upstream/dbus.git] / 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   return getenv (varname);
186 }
187
188 /**
189  * Wrapper for clearenv().
190  *
191  * @returns #TRUE on success.
192  */
193 dbus_bool_t
194 _dbus_clearenv (void)
195 {
196   dbus_bool_t rc = TRUE;
197
198 #ifdef HAVE_CLEARENV
199   if (clearenv () != 0)
200      rc = FALSE;
201 #else
202
203   if (environ != NULL)
204     environ[0] = NULL;
205 #endif
206
207   return rc;
208 }
209
210 /**
211  * Gets a #NULL-terminated list of key=value pairs from the
212  * environment. Use dbus_free_string_array to free it.
213  *
214  * @returns the environment or #NULL on OOM
215  */
216 char **
217 _dbus_get_environment (void)
218 {
219   int i, length;
220   char **environment;
221
222   _dbus_assert (environ != NULL);
223
224   for (length = 0; environ[length] != NULL; length++);
225
226   /* Add one for NULL */
227   length++;
228
229   environment = dbus_new0 (char *, length);
230
231   if (environment == NULL)
232     return NULL;
233
234   for (i = 0; environ[i] != NULL; i++)
235     {
236       environment[i] = _dbus_strdup (environ[i]);
237
238       if (environment[i] == NULL)
239         break;
240     }
241
242   if (environ[i] != NULL)
243     {
244       dbus_free_string_array (environment);
245       environment = NULL;
246     }
247
248   return environment;
249 }
250
251 /**
252  * Split paths into a list of char strings
253  * 
254  * @param dirs string with pathes 
255  * @param suffix string concated to each path in dirs
256  * @param dir_list contains a list of splitted pathes
257  * return #TRUE is pathes could be splittes,#FALSE in oom case 
258  */
259 dbus_bool_t
260 _dbus_split_paths_and_append (DBusString *dirs, 
261                               const char *suffix, 
262                               DBusList  **dir_list)
263 {
264    int start;
265    int i;
266    int len;
267    char *cpath;
268    DBusString file_suffix;
269
270    start = 0;
271    i = 0;
272
273    _dbus_string_init_const (&file_suffix, suffix);
274
275    len = _dbus_string_get_length (dirs);
276
277    while (_dbus_string_find (dirs, start, _DBUS_PATH_SEPARATOR, &i))
278      {
279        DBusString path;
280
281        if (!_dbus_string_init (&path))
282           goto oom;
283
284        if (!_dbus_string_copy_len (dirs,
285                                    start,
286                                    i - start,
287                                    &path,
288                                    0))
289           {
290             _dbus_string_free (&path);
291             goto oom;
292           }
293
294         _dbus_string_chop_white (&path);
295
296         /* check for an empty path */
297         if (_dbus_string_get_length (&path) == 0)
298           goto next;
299
300         if (!_dbus_concat_dir_and_file (&path,
301                                         &file_suffix))
302           {
303             _dbus_string_free (&path);
304             goto oom;
305           }
306
307         if (!_dbus_string_copy_data(&path, &cpath))
308           {
309             _dbus_string_free (&path);
310             goto oom;
311           }
312
313         if (!_dbus_list_append (dir_list, cpath))
314           {
315             _dbus_string_free (&path);              
316             dbus_free (cpath);
317             goto oom;
318           }
319
320        next:
321         _dbus_string_free (&path);
322         start = i + 1;
323     } 
324       
325   if (start != len)
326     { 
327       DBusString path;
328
329       if (!_dbus_string_init (&path))
330         goto oom;
331
332       if (!_dbus_string_copy_len (dirs,
333                                   start,
334                                   len - start,
335                                   &path,
336                                   0))
337         {
338           _dbus_string_free (&path);
339           goto oom;
340         }
341
342       if (!_dbus_concat_dir_and_file (&path,
343                                       &file_suffix))
344         {
345           _dbus_string_free (&path);
346           goto oom;
347         }
348
349       if (!_dbus_string_copy_data(&path, &cpath))
350         {
351           _dbus_string_free (&path);
352           goto oom;
353         }
354
355       if (!_dbus_list_append (dir_list, cpath))
356         {
357           _dbus_string_free (&path);              
358           dbus_free (cpath);
359           goto oom;
360         }
361
362       _dbus_string_free (&path); 
363     }
364
365   return TRUE;
366
367  oom:
368   _dbus_list_foreach (dir_list, (DBusForeachFunction)dbus_free, NULL); 
369   _dbus_list_clear (dir_list);
370   return FALSE;
371 }
372
373 /** @} */
374
375 /**
376  * @addtogroup DBusString
377  *
378  * @{
379  */
380 /**
381  * Appends an integer to a DBusString.
382  * 
383  * @param str the string
384  * @param value the integer value
385  * @returns #FALSE if not enough memory or other failure.
386  */
387 dbus_bool_t
388 _dbus_string_append_int (DBusString *str,
389                          long        value)
390 {
391   /* this calculation is from comp.lang.c faq */
392 #define MAX_LONG_LEN ((sizeof (long) * 8 + 2) / 3 + 1)  /* +1 for '-' */
393   int orig_len;
394   int i;
395   char *buf;
396   
397   orig_len = _dbus_string_get_length (str);
398
399   if (!_dbus_string_lengthen (str, MAX_LONG_LEN))
400     return FALSE;
401
402   buf = _dbus_string_get_data_len (str, orig_len, MAX_LONG_LEN);
403
404   snprintf (buf, MAX_LONG_LEN, "%ld", value);
405
406   i = 0;
407   while (*buf)
408     {
409       ++buf;
410       ++i;
411     }
412   
413   _dbus_string_shorten (str, MAX_LONG_LEN - i);
414   
415   return TRUE;
416 }
417
418 /**
419  * Appends an unsigned integer to a DBusString.
420  * 
421  * @param str the string
422  * @param value the integer value
423  * @returns #FALSE if not enough memory or other failure.
424  */
425 dbus_bool_t
426 _dbus_string_append_uint (DBusString    *str,
427                           unsigned long  value)
428 {
429   /* this is wrong, but definitely on the high side. */
430 #define MAX_ULONG_LEN (MAX_LONG_LEN * 2)
431   int orig_len;
432   int i;
433   char *buf;
434   
435   orig_len = _dbus_string_get_length (str);
436
437   if (!_dbus_string_lengthen (str, MAX_ULONG_LEN))
438     return FALSE;
439
440   buf = _dbus_string_get_data_len (str, orig_len, MAX_ULONG_LEN);
441
442   snprintf (buf, MAX_ULONG_LEN, "%lu", value);
443
444   i = 0;
445   while (*buf)
446     {
447       ++buf;
448       ++i;
449     }
450   
451   _dbus_string_shorten (str, MAX_ULONG_LEN - i);
452   
453   return TRUE;
454 }
455
456 #ifdef DBUS_BUILD_TESTS
457 /**
458  * Appends a double to a DBusString.
459  * 
460  * @param str the string
461  * @param value the floating point value
462  * @returns #FALSE if not enough memory or other failure.
463  */
464 dbus_bool_t
465 _dbus_string_append_double (DBusString *str,
466                             double      value)
467 {
468 #define MAX_DOUBLE_LEN 64 /* this is completely made up :-/ */
469   int orig_len;
470   char *buf;
471   int i;
472   
473   orig_len = _dbus_string_get_length (str);
474
475   if (!_dbus_string_lengthen (str, MAX_DOUBLE_LEN))
476     return FALSE;
477
478   buf = _dbus_string_get_data_len (str, orig_len, MAX_DOUBLE_LEN);
479
480   snprintf (buf, MAX_LONG_LEN, "%g", value);
481
482   i = 0;
483   while (*buf)
484     {
485       ++buf;
486       ++i;
487     }
488   
489   _dbus_string_shorten (str, MAX_DOUBLE_LEN - i);
490   
491   return TRUE;
492 }
493 #endif /* DBUS_BUILD_TESTS */
494
495 /**
496  * Parses an integer contained in a DBusString. Either return parameter
497  * may be #NULL if you aren't interested in it. The integer is parsed
498  * and stored in value_return. Return parameters are not initialized
499  * if the function returns #FALSE.
500  *
501  * @param str the string
502  * @param start the byte index of the start of the integer
503  * @param value_return return location of the integer value or #NULL
504  * @param end_return return location of the end of the integer, or #NULL
505  * @returns #TRUE on success
506  */
507 dbus_bool_t
508 _dbus_string_parse_int (const DBusString *str,
509                         int               start,
510                         long             *value_return,
511                         int              *end_return)
512 {
513   long v;
514   const char *p;
515   char *end;
516
517   p = _dbus_string_get_const_data_len (str, start,
518                                        _dbus_string_get_length (str) - start);
519
520   end = NULL;
521   _dbus_set_errno_to_zero ();
522   v = strtol (p, &end, 0);
523   if (end == NULL || end == p || errno != 0)
524     return FALSE;
525
526   if (value_return)
527     *value_return = v;
528   if (end_return)
529     *end_return = start + (end - p);
530
531   return TRUE;
532 }
533
534 /**
535  * Parses an unsigned integer contained in a DBusString. Either return
536  * parameter may be #NULL if you aren't interested in it. The integer
537  * is parsed and stored in value_return. Return parameters are not
538  * initialized if the function returns #FALSE.
539  *
540  * @param str the string
541  * @param start the byte index of the start of the integer
542  * @param value_return return location of the integer value or #NULL
543  * @param end_return return location of the end of the integer, or #NULL
544  * @returns #TRUE on success
545  */
546 dbus_bool_t
547 _dbus_string_parse_uint (const DBusString *str,
548                          int               start,
549                          unsigned long    *value_return,
550                          int              *end_return)
551 {
552   unsigned long v;
553   const char *p;
554   char *end;
555
556   p = _dbus_string_get_const_data_len (str, start,
557                                        _dbus_string_get_length (str) - start);
558
559   end = NULL;
560   _dbus_set_errno_to_zero ();
561   v = strtoul (p, &end, 0);
562   if (end == NULL || end == p || errno != 0)
563     return FALSE;
564
565   if (value_return)
566     *value_return = v;
567   if (end_return)
568     *end_return = start + (end - p);
569
570   return TRUE;
571 }
572
573 #ifdef DBUS_BUILD_TESTS
574 static dbus_bool_t
575 ascii_isspace (char c)
576 {
577   return (c == ' ' ||
578           c == '\f' ||
579           c == '\n' ||
580           c == '\r' ||
581           c == '\t' ||
582           c == '\v');
583 }
584 #endif /* DBUS_BUILD_TESTS */
585
586 #ifdef DBUS_BUILD_TESTS
587 static dbus_bool_t
588 ascii_isdigit (char c)
589 {
590   return c >= '0' && c <= '9';
591 }
592 #endif /* DBUS_BUILD_TESTS */
593
594 #ifdef DBUS_BUILD_TESTS
595 static dbus_bool_t
596 ascii_isxdigit (char c)
597 {
598   return (ascii_isdigit (c) ||
599           (c >= 'a' && c <= 'f') ||
600           (c >= 'A' && c <= 'F'));
601 }
602 #endif /* DBUS_BUILD_TESTS */
603
604 #ifdef DBUS_BUILD_TESTS
605 /* Calls strtod in a locale-independent fashion, by looking at
606  * the locale data and patching the decimal comma to a point.
607  *
608  * Relicensed from glib.
609  */
610 static double
611 ascii_strtod (const char *nptr,
612               char      **endptr)
613 {
614   /* FIXME: The Win32 C library's strtod() doesn't handle hex.
615    * Presumably many Unixes don't either.
616    */
617
618   char *fail_pos;
619   double val;
620   struct lconv *locale_data;
621   const char *decimal_point;
622   int decimal_point_len;
623   const char *p, *decimal_point_pos;
624   const char *end = NULL; /* Silence gcc */
625
626   fail_pos = NULL;
627
628 #if HAVE_LOCALECONV
629   locale_data = localeconv ();
630   decimal_point = locale_data->decimal_point;
631 #else
632   decimal_point = ".";
633 #endif
634
635   decimal_point_len = strlen (decimal_point);
636   _dbus_assert (decimal_point_len != 0);
637   
638   decimal_point_pos = NULL;
639   if (decimal_point[0] != '.' ||
640       decimal_point[1] != 0)
641     {
642       p = nptr;
643       /* Skip leading space */
644       while (ascii_isspace (*p))
645         p++;
646       
647       /* Skip leading optional sign */
648       if (*p == '+' || *p == '-')
649         p++;
650       
651       if (p[0] == '0' &&
652           (p[1] == 'x' || p[1] == 'X'))
653         {
654           p += 2;
655           /* HEX - find the (optional) decimal point */
656           
657           while (ascii_isxdigit (*p))
658             p++;
659           
660           if (*p == '.')
661             {
662               decimal_point_pos = p++;
663               
664               while (ascii_isxdigit (*p))
665                 p++;
666               
667               if (*p == 'p' || *p == 'P')
668                 p++;
669               if (*p == '+' || *p == '-')
670                 p++;
671               while (ascii_isdigit (*p))
672                 p++;
673               end = p;
674             }
675         }
676       else
677         {
678           while (ascii_isdigit (*p))
679             p++;
680           
681           if (*p == '.')
682             {
683               decimal_point_pos = p++;
684               
685               while (ascii_isdigit (*p))
686                 p++;
687               
688               if (*p == 'e' || *p == 'E')
689                 p++;
690               if (*p == '+' || *p == '-')
691                 p++;
692               while (ascii_isdigit (*p))
693                 p++;
694               end = p;
695             }
696         }
697       /* For the other cases, we need not convert the decimal point */
698     }
699
700   /* Set errno to zero, so that we can distinguish zero results
701      and underflows */
702   _dbus_set_errno_to_zero ();
703   
704   if (decimal_point_pos)
705     {
706       char *copy, *c;
707
708       /* We need to convert the '.' to the locale specific decimal point */
709       copy = dbus_malloc (end - nptr + 1 + decimal_point_len);
710       
711       c = copy;
712       memcpy (c, nptr, decimal_point_pos - nptr);
713       c += decimal_point_pos - nptr;
714       memcpy (c, decimal_point, decimal_point_len);
715       c += decimal_point_len;
716       memcpy (c, decimal_point_pos + 1, end - (decimal_point_pos + 1));
717       c += end - (decimal_point_pos + 1);
718       *c = 0;
719
720       val = strtod (copy, &fail_pos);
721
722       if (fail_pos)
723         {
724           if (fail_pos > decimal_point_pos)
725             fail_pos = (char *)nptr + (fail_pos - copy) - (decimal_point_len - 1);
726           else
727             fail_pos = (char *)nptr + (fail_pos - copy);
728         }
729       
730       dbus_free (copy);
731           
732     }
733   else
734     val = strtod (nptr, &fail_pos);
735
736   if (endptr)
737     *endptr = fail_pos;
738   
739   return val;
740 }
741 #endif /* DBUS_BUILD_TESTS */
742
743 #ifdef DBUS_BUILD_TESTS
744 /**
745  * Parses a floating point number contained in a DBusString. Either
746  * return parameter may be #NULL if you aren't interested in it. The
747  * integer is parsed and stored in value_return. Return parameters are
748  * not initialized if the function returns #FALSE.
749  *
750  * @param str the string
751  * @param start the byte index of the start of the float
752  * @param value_return return location of the float value or #NULL
753  * @param end_return return location of the end of the float, or #NULL
754  * @returns #TRUE on success
755  */
756 dbus_bool_t
757 _dbus_string_parse_double (const DBusString *str,
758                            int               start,
759                            double           *value_return,
760                            int              *end_return)
761 {
762   double v;
763   const char *p;
764   char *end;
765
766   p = _dbus_string_get_const_data_len (str, start,
767                                        _dbus_string_get_length (str) - start);
768
769   /* parsing hex works on linux but isn't portable, so intercept it
770    * here to get uniform behavior.
771    */
772   if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X'))
773     return FALSE;
774   
775   end = NULL;
776   _dbus_set_errno_to_zero ();
777   v = ascii_strtod (p, &end);
778   if (end == NULL || end == p || errno != 0)
779     return FALSE;
780
781   if (value_return)
782     *value_return = v;
783   if (end_return)
784     *end_return = start + (end - p);
785
786   return TRUE;
787 }
788 #endif /* DBUS_BUILD_TESTS */
789
790 /** @} */ /* DBusString group */
791
792 /**
793  * @addtogroup DBusInternalsUtils
794  * @{
795  */
796
797 void
798 _dbus_generate_pseudorandom_bytes_buffer (char *buffer,
799                                           int   n_bytes)
800 {
801   long tv_usec;
802   int i;
803   
804   /* fall back to pseudorandom */
805   _dbus_verbose ("Falling back to pseudorandom for %d bytes\n",
806                  n_bytes);
807   
808   _dbus_get_current_time (NULL, &tv_usec);
809   srand (tv_usec);
810   
811   i = 0;
812   while (i < n_bytes)
813     {
814       double r;
815       unsigned int b;
816           
817       r = rand ();
818       b = (r / (double) RAND_MAX) * 255.0;
819
820       buffer[i] = b;
821
822       ++i;
823     }
824 }
825
826 /**
827  * Fills n_bytes of the given buffer with random bytes.
828  *
829  * @param buffer an allocated buffer
830  * @param n_bytes the number of bytes in buffer to write to
831  */
832 void
833 _dbus_generate_random_bytes_buffer (char *buffer,
834                                     int   n_bytes)
835 {
836   DBusString str;
837
838   if (!_dbus_string_init (&str))
839     {
840       _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes);
841       return;
842     }
843
844   if (!_dbus_generate_random_bytes (&str, n_bytes))
845     {
846       _dbus_string_free (&str);
847       _dbus_generate_pseudorandom_bytes_buffer (buffer, n_bytes);
848       return;
849     }
850
851   _dbus_string_copy_to_buffer (&str, buffer, n_bytes);
852
853   _dbus_string_free (&str);
854 }
855
856 /**
857  * Generates the given number of random bytes, where the bytes are
858  * chosen from the alphanumeric ASCII subset.
859  *
860  * @param str the string
861  * @param n_bytes the number of random ASCII bytes to append to string
862  * @returns #TRUE on success, #FALSE if no memory or other failure
863  */
864 dbus_bool_t
865 _dbus_generate_random_ascii (DBusString *str,
866                              int         n_bytes)
867 {
868   static const char letters[] =
869     "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789abcdefghijklmnopqrstuvwxyz";
870   int i;
871   int len;
872   
873   if (!_dbus_generate_random_bytes (str, n_bytes))
874     return FALSE;
875   
876   len = _dbus_string_get_length (str);
877   i = len - n_bytes;
878   while (i < len)
879     {
880       _dbus_string_set_byte (str, i,
881                              letters[_dbus_string_get_byte (str, i) %
882                                      (sizeof (letters) - 1)]);
883
884       ++i;
885     }
886
887   _dbus_assert (_dbus_string_validate_ascii (str, len - n_bytes,
888                                              n_bytes));
889
890   return TRUE;
891 }
892
893 /**
894  * Converts a UNIX errno, or Windows errno or WinSock error value into
895  * a #DBusError name.
896  *
897  * @todo should cover more errnos, specifically those
898  * from open().
899  * 
900  * @param error_number the errno.
901  * @returns an error name
902  */
903 const char*
904 _dbus_error_from_errno (int error_number)
905 {
906   switch (error_number)
907     {
908     case 0:
909       return DBUS_ERROR_FAILED;
910       
911 #ifdef EPROTONOSUPPORT
912     case EPROTONOSUPPORT:
913       return DBUS_ERROR_NOT_SUPPORTED;
914 #endif
915 #ifdef WSAEPROTONOSUPPORT
916     case WSAEPROTONOSUPPORT:
917       return DBUS_ERROR_NOT_SUPPORTED;
918 #endif
919 #ifdef EAFNOSUPPORT
920     case EAFNOSUPPORT:
921       return DBUS_ERROR_NOT_SUPPORTED;
922 #endif
923 #ifdef WSAEAFNOSUPPORT
924     case WSAEAFNOSUPPORT:
925       return DBUS_ERROR_NOT_SUPPORTED;
926 #endif
927 #ifdef ENFILE
928     case ENFILE:
929       return DBUS_ERROR_LIMITS_EXCEEDED; /* kernel out of memory */
930 #endif
931 #ifdef EMFILE
932     case EMFILE:
933       return DBUS_ERROR_LIMITS_EXCEEDED;
934 #endif
935 #ifdef EACCES
936     case EACCES:
937       return DBUS_ERROR_ACCESS_DENIED;
938 #endif
939 #ifdef EPERM
940     case EPERM:
941       return DBUS_ERROR_ACCESS_DENIED;
942 #endif
943 #ifdef ENOBUFS
944     case ENOBUFS:
945       return DBUS_ERROR_NO_MEMORY;
946 #endif
947 #ifdef ENOMEM
948     case ENOMEM:
949       return DBUS_ERROR_NO_MEMORY;
950 #endif
951 #ifdef ECONNREFUSED
952     case ECONNREFUSED:
953       return DBUS_ERROR_NO_SERVER;
954 #endif
955 #ifdef WSAECONNREFUSED
956     case WSAECONNREFUSED:
957       return DBUS_ERROR_NO_SERVER;
958 #endif
959 #ifdef ETIMEDOUT
960     case ETIMEDOUT:
961       return DBUS_ERROR_TIMEOUT;
962 #endif
963 #ifdef WSAETIMEDOUT
964     case WSAETIMEDOUT:
965       return DBUS_ERROR_TIMEOUT;
966 #endif
967 #ifdef ENETUNREACH
968     case ENETUNREACH:
969       return DBUS_ERROR_NO_NETWORK;
970 #endif
971 #ifdef WSAENETUNREACH
972     case WSAENETUNREACH:
973       return DBUS_ERROR_NO_NETWORK;
974 #endif
975 #ifdef EADDRINUSE
976     case EADDRINUSE:
977       return DBUS_ERROR_ADDRESS_IN_USE;
978 #endif
979 #ifdef WSAEADDRINUSE
980     case WSAEADDRINUSE:
981       return DBUS_ERROR_ADDRESS_IN_USE;
982 #endif
983 #ifdef EEXIST
984     case EEXIST:
985       return DBUS_ERROR_FILE_EXISTS;
986 #endif
987 #ifdef ENOENT
988     case ENOENT:
989       return DBUS_ERROR_FILE_NOT_FOUND;
990 #endif
991     }
992
993   return DBUS_ERROR_FAILED;
994 }
995
996 /**
997  * Converts the current system errno value into a #DBusError name.
998  *
999  * @returns an error name
1000  */
1001 const char*
1002 _dbus_error_from_system_errno (void)
1003 {
1004   return _dbus_error_from_errno (errno);
1005 }
1006
1007 /**
1008  * Assign 0 to the global errno variable
1009  */
1010 void
1011 _dbus_set_errno_to_zero (void)
1012 {
1013 #ifdef DBUS_WINCE
1014   SetLastError (0);
1015 #else
1016   errno = 0;
1017 #endif
1018 }
1019
1020 /**
1021  * See if errno is set
1022  * @returns #TRUE if errno is not 0
1023  */
1024 dbus_bool_t
1025 _dbus_get_is_errno_nonzero (void)
1026 {
1027   return errno != 0;
1028 }
1029
1030 /**
1031  * See if errno is ENOMEM
1032  * @returns #TRUE if errno == ENOMEM
1033  */
1034 dbus_bool_t
1035 _dbus_get_is_errno_enomem (void)
1036 {
1037   return errno == ENOMEM;
1038 }
1039
1040 /**
1041  * See if errno is EINTR
1042  * @returns #TRUE if errno == EINTR
1043  */
1044 dbus_bool_t
1045 _dbus_get_is_errno_eintr (void)
1046 {
1047   return errno == EINTR;
1048 }
1049
1050 /**
1051  * See if errno is EPIPE
1052  * @returns #TRUE if errno == EPIPE
1053  */
1054 dbus_bool_t
1055 _dbus_get_is_errno_epipe (void)
1056 {
1057   return errno == EPIPE;
1058 }
1059
1060 /**
1061  * Get error message from errno
1062  * @returns _dbus_strerror(errno)
1063  */
1064 const char*
1065 _dbus_strerror_from_errno (void)
1066 {
1067   return _dbus_strerror (errno);
1068 }
1069
1070 /** @} end of sysdeps */
1071
1072 /* tests in dbus-sysdeps-util.c */