2003-04-02 Havoc Pennington <hp@redhat.com>
+ * dbus/dbus-sysdeps.c (_dbus_file_get_contents): include filenames
+ in error messages
+ (_dbus_string_get_dirname): new
+ (_dbus_sysdeps_test): new
+ (_dbus_directory_open): include dirnames in error messages
+
+ * bus/config-parser.c: interpret <include> and <includedir> and
+ <servicedir> relative to config file location if the given
+ filename is not absolute.
+
+ * dbus/dbus-string.c (_dbus_string_find_byte_backward): new
+
+2003-04-02 Havoc Pennington <hp@redhat.com>
+
* bus/connection.c (bus_transaction_send_error_reply): set sender
service for the error, and unref the reply on success
const char *filename;
BusConfigParser *parser;
ExpatParseContext context;
-
+ DBusString dirname;
+
_DBUS_ASSERT_ERROR_IS_CLEAR (error);
parser = NULL;
return NULL;
}
+ if (!_dbus_string_init (&dirname))
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ _dbus_string_free (&context.content);
+ return NULL;
+ }
+
expat = XML_ParserCreate_MM ("UTF-8", &memsuite, NULL);
if (expat == NULL)
{
goto failed;
}
- parser = bus_config_parser_new ();
+ if (!_dbus_string_get_dirname (file, &dirname))
+ {
+ dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ goto failed;
+ }
+
+ parser = bus_config_parser_new (&dirname);
if (parser == NULL)
{
dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
if (!bus_config_parser_finished (parser, error))
goto failed;
+ _dbus_string_free (&dirname);
_dbus_string_free (&context.content);
XML_ParserFree (expat);
failed:
_DBUS_ASSERT_ERROR_IS_SET (error);
+ _dbus_string_free (&dirname);
_dbus_string_free (&context.content);
if (expat)
XML_ParserFree (expat);
*/
#include "config-parser.h"
#include "test.h"
+#include "utils.h"
#include <dbus/dbus-list.h>
#include <dbus/dbus-internals.h>
#include <string.h>
{
int refcount;
+ DBusString basedir; /**< Directory we resolve paths relative to */
+
DBusList *stack; /**< stack of Element */
char *user; /**< user to run as */
}
BusConfigParser*
-bus_config_parser_new (void)
+bus_config_parser_new (const DBusString *basedir)
{
BusConfigParser *parser;
if (parser == NULL)
return NULL;
+ if (!_dbus_string_init (&parser->basedir))
+ {
+ dbus_free (parser);
+ return NULL;
+ }
+
+ if (!_dbus_string_copy (basedir, 0, &parser->basedir, 0))
+ {
+ _dbus_string_free (&parser->basedir);
+ dbus_free (parser);
+ return NULL;
+ }
+
parser->refcount = 1;
return parser;
NULL);
_dbus_list_clear (&parser->service_dirs);
+
+ _dbus_string_free (&parser->basedir);
dbus_free (parser);
}
}
static dbus_bool_t
+make_full_path (const DBusString *basedir,
+ const DBusString *filename,
+ DBusString *full_path)
+{
+ if (_dbus_path_is_absolute (filename))
+ {
+ return _dbus_string_copy (filename, 0, full_path, 0);
+ }
+ else
+ {
+ if (!_dbus_string_copy (basedir, 0, full_path, 0))
+ return FALSE;
+
+ if (!_dbus_concat_dir_and_file (full_path, filename))
+ return FALSE;
+
+ return TRUE;
+ }
+}
+
+static dbus_bool_t
include_file (BusConfigParser *parser,
const DBusString *filename,
dbus_bool_t ignore_missing,
if (!_dbus_string_init (&filename))
{
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ BUS_SET_OOM (error);
return FALSE;
}
retval = FALSE;
dir = _dbus_directory_open (dirname, error);
-
- /* FIXME this is just so the tests pass for now, it needs to come out
- * once I implement make-dirname-relative-to-currently-parsed-files-dir
- */
- if (dir == NULL)
- {
- if (error)
- dbus_error_free (error);
- _dbus_string_free (&filename);
- return TRUE;
- }
if (dir == NULL)
goto failed;
-
+
+ dbus_error_init (&tmp_error);
while (_dbus_directory_get_next_file (dir, &filename, &tmp_error))
{
- if (_dbus_string_ends_with_c_str (&filename, ".conf"))
+ DBusString full_path;
+
+ if (!_dbus_string_init (&full_path))
+ {
+ BUS_SET_OOM (error);
+ goto failed;
+ }
+
+ if (!_dbus_string_copy (dirname, 0, &full_path, 0))
+ {
+ BUS_SET_OOM (error);
+ _dbus_string_free (&full_path);
+ goto failed;
+ }
+
+ if (!_dbus_concat_dir_and_file (&full_path, &filename))
+ {
+ BUS_SET_OOM (error);
+ _dbus_string_free (&full_path);
+ goto failed;
+ }
+
+ if (_dbus_string_ends_with_c_str (&full_path, ".conf"))
{
- if (!include_file (parser, &filename, TRUE, error))
- goto failed;
+ if (!include_file (parser, &full_path, TRUE, error))
+ {
+ _dbus_string_free (&full_path);
+ goto failed;
+ }
}
+
+ _dbus_string_free (&full_path);
}
if (dbus_error_is_set (&tmp_error))
case ELEMENT_INCLUDE:
{
+ DBusString full_path;
+
e->had_content = TRUE;
- if (!include_file (parser, content,
+ if (!_dbus_string_init (&full_path))
+ goto nomem;
+
+ if (!make_full_path (&parser->basedir, content, &full_path))
+ {
+ _dbus_string_free (&full_path);
+ goto nomem;
+ }
+
+ if (!include_file (parser, &full_path,
e->d.include.ignore_missing, error))
- return FALSE;
+ {
+ _dbus_string_free (&full_path);
+ return FALSE;
+ }
+
+ _dbus_string_free (&full_path);
}
break;
case ELEMENT_INCLUDEDIR:
{
+ DBusString full_path;
+
e->had_content = TRUE;
+
+ if (!_dbus_string_init (&full_path))
+ goto nomem;
- if (!include_dir (parser, content, error))
- return FALSE;
+ if (!make_full_path (&parser->basedir, content, &full_path))
+ {
+ _dbus_string_free (&full_path);
+ goto nomem;
+ }
+
+ if (!include_dir (parser, &full_path, error))
+ {
+ _dbus_string_free (&full_path);
+ return FALSE;
+ }
+
+ _dbus_string_free (&full_path);
}
break;
case ELEMENT_SERVICEDIR:
{
char *s;
-
- e->had_content = TRUE;
+ DBusString full_path;
- if (!_dbus_string_copy_data (content, &s))
+ e->had_content = TRUE;
+
+ if (!_dbus_string_init (&full_path))
goto nomem;
+
+ if (!make_full_path (&parser->basedir, content, &full_path))
+ {
+ _dbus_string_free (&full_path);
+ goto nomem;
+ }
+
+ if (!_dbus_string_copy_data (&full_path, &s))
+ {
+ _dbus_string_free (&full_path);
+ goto nomem;
+ }
- if (!_dbus_list_append (&parser->service_dirs,
- s))
+ if (!_dbus_list_append (&parser->service_dirs, s))
{
+ _dbus_string_free (&full_path);
dbus_free (s);
goto nomem;
}
+
+ _dbus_string_free (&full_path);
}
break;
}
return TRUE;
nomem:
- dbus_set_error (error, DBUS_ERROR_NO_MEMORY, NULL);
+ BUS_SET_OOM (error);
return FALSE;
}
typedef struct BusConfigParser BusConfigParser;
-BusConfigParser* bus_config_parser_new (void);
+BusConfigParser* bus_config_parser_new (const DBusString *basedir);
void bus_config_parser_ref (BusConfigParser *parser);
void bus_config_parser_unref (BusConfigParser *parser);
dbus_bool_t bus_config_parser_check_doctype (BusConfigParser *parser,
}
/**
+ * Find the given byte scanning backward from the given start.
+ * Sets *found to -1 if the byte is not found.
+ *
+ * @param str the string
+ * @param byte the byte to find
+ * @param found return location for where it was found
+ * @returns #TRUE if found
+ */
+dbus_bool_t
+_dbus_string_find_byte_backward (const DBusString *str,
+ int start,
+ unsigned char byte,
+ int *found)
+{
+ int i;
+ DBUS_CONST_STRING_PREAMBLE (str);
+ _dbus_assert (start <= real->len);
+ _dbus_assert (start >= 0);
+ _dbus_assert (found != NULL);
+
+ i = start - 1;
+ while (i >= 0)
+ {
+ if (real->str[i] == byte)
+ break;
+
+ --i;
+ }
+
+ if (found)
+ *found = i;
+
+ return i >= 0;
+}
+
+/**
* Finds a blank (space or tab) in the string. Returns #TRUE
* if found, #FALSE otherwise. If a blank is not found sets
* *found to the length of the string.
if (_dbus_string_find_to (&str, 0, 2, "Hello", NULL))
_dbus_assert_not_reached ("Did find 'Hello'");
+
+ if (!_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str), 'H', &i))
+ _dbus_assert_not_reached ("Did not find 'H'");
+ _dbus_assert (i == 0);
+
+ if (!_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str), 'o', &i))
+ _dbus_assert_not_reached ("Did not find 'o'");
+ _dbus_assert (i == _dbus_string_get_length (&str) - 1);
+
+ if (_dbus_string_find_byte_backward (&str, _dbus_string_get_length (&str) - 1, 'o', &i))
+ _dbus_assert_not_reached ("Did find 'o'");
+ _dbus_assert (i == -1);
+
+ if (_dbus_string_find_byte_backward (&str, 1, 'e', &i))
+ _dbus_assert_not_reached ("Did find 'e'");
+ _dbus_assert (i == -1);
+
+ if (!_dbus_string_find_byte_backward (&str, 2, 'e', &i))
+ _dbus_assert_not_reached ("Didn't find 'e'");
+ _dbus_assert (i == 1);
_dbus_string_free (&str);
unsigned int dummy8 : 3; /**< placeholder */
};
-dbus_bool_t _dbus_string_init (DBusString *str);
-void _dbus_string_init_const (DBusString *str,
- const char *value);
-void _dbus_string_init_const_len (DBusString *str,
- const char *value,
- int len);
-void _dbus_string_free (DBusString *str);
-void _dbus_string_lock (DBusString *str);
+dbus_bool_t _dbus_string_init (DBusString *str);
+void _dbus_string_init_const (DBusString *str,
+ const char *value);
+void _dbus_string_init_const_len (DBusString *str,
+ const char *value,
+ int len);
+void _dbus_string_free (DBusString *str);
+void _dbus_string_lock (DBusString *str);
+char* _dbus_string_get_data (DBusString *str);
+const char* _dbus_string_get_const_data (const DBusString *str);
+char* _dbus_string_get_data_len (DBusString *str,
+ int start,
+ int len);
+const char* _dbus_string_get_const_data_len (const DBusString *str,
+ int start,
+ int len);
+void _dbus_string_set_byte (DBusString *str,
+ int i,
+ unsigned char byte);
+unsigned char _dbus_string_get_byte (const DBusString *str,
+ int start);
+dbus_bool_t _dbus_string_insert_byte (DBusString *str,
+ int i,
+ unsigned char byte);
+dbus_bool_t _dbus_string_steal_data (DBusString *str,
+ char **data_return);
+dbus_bool_t _dbus_string_steal_data_len (DBusString *str,
+ char **data_return,
+ int start,
+ int len);
+dbus_bool_t _dbus_string_copy_data (const DBusString *str,
+ char **data_return);
+dbus_bool_t _dbus_string_copy_data_len (const DBusString *str,
+ char **data_return,
+ int start,
+ int len);
+int _dbus_string_get_length (const DBusString *str);
+dbus_bool_t _dbus_string_lengthen (DBusString *str,
+ int additional_length);
+void _dbus_string_shorten (DBusString *str,
+ int length_to_remove);
+dbus_bool_t _dbus_string_set_length (DBusString *str,
+ int length);
+dbus_bool_t _dbus_string_align_length (DBusString *str,
+ int alignment);
+dbus_bool_t _dbus_string_append (DBusString *str,
+ const char *buffer);
+dbus_bool_t _dbus_string_append_len (DBusString *str,
+ const char *buffer,
+ int len);
+dbus_bool_t _dbus_string_append_int (DBusString *str,
+ long value);
+dbus_bool_t _dbus_string_append_uint (DBusString *str,
+ unsigned long value);
+dbus_bool_t _dbus_string_append_double (DBusString *str,
+ double value);
+dbus_bool_t _dbus_string_append_byte (DBusString *str,
+ unsigned char byte);
+dbus_bool_t _dbus_string_append_unichar (DBusString *str,
+ dbus_unichar_t ch);
+void _dbus_string_delete (DBusString *str,
+ int start,
+ int len);
+dbus_bool_t _dbus_string_move (DBusString *source,
+ int start,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_copy (const DBusString *source,
+ int start,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_move_len (DBusString *source,
+ int start,
+ int len,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_copy_len (const DBusString *source,
+ int start,
+ int len,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_replace_len (const DBusString *source,
+ int start,
+ int len,
+ DBusString *dest,
+ int replace_at,
+ int replace_len);
+void _dbus_string_get_unichar (const DBusString *str,
+ int start,
+ dbus_unichar_t *ch_return,
+ int *end_return);
+dbus_bool_t _dbus_string_parse_int (const DBusString *str,
+ int start,
+ long *value_return,
+ int *end_return);
+dbus_bool_t _dbus_string_parse_uint (const DBusString *str,
+ int start,
+ unsigned long *value_return,
+ int *end_return);
+dbus_bool_t _dbus_string_parse_double (const DBusString *str,
+ int start,
+ double *value,
+ int *end_return);
+dbus_bool_t _dbus_string_find (const DBusString *str,
+ int start,
+ const char *substr,
+ int *found);
+dbus_bool_t _dbus_string_find_to (const DBusString *str,
+ int start,
+ int end,
+ const char *substr,
+ int *found);
+dbus_bool_t _dbus_string_find_byte_backward (const DBusString *str,
+ int start,
+ unsigned char byte,
+ int *found);
+dbus_bool_t _dbus_string_find_blank (const DBusString *str,
+ int start,
+ int *found);
+void _dbus_string_skip_blank (const DBusString *str,
+ int start,
+ int *end);
+void _dbus_string_skip_white (const DBusString *str,
+ int start,
+ int *end);
+dbus_bool_t _dbus_string_equal (const DBusString *a,
+ const DBusString *b);
+dbus_bool_t _dbus_string_equal_c_str (const DBusString *a,
+ const char *c_str);
+dbus_bool_t _dbus_string_equal_len (const DBusString *a,
+ const DBusString *b,
+ int len);
+dbus_bool_t _dbus_string_starts_with_c_str (const DBusString *a,
+ const char *c_str);
+dbus_bool_t _dbus_string_ends_with_c_str (const DBusString *a,
+ const char *c_str);
+dbus_bool_t _dbus_string_pop_line (DBusString *source,
+ DBusString *dest);
+void _dbus_string_delete_first_word (DBusString *str);
+void _dbus_string_delete_leading_blanks (DBusString *str);
+dbus_bool_t _dbus_string_base64_encode (const DBusString *source,
+ int start,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_base64_decode (const DBusString *source,
+ int start,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_hex_encode (const DBusString *source,
+ int start,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_hex_decode (const DBusString *source,
+ int start,
+ DBusString *dest,
+ int insert_at);
+dbus_bool_t _dbus_string_validate_ascii (const DBusString *str,
+ int start,
+ int len);
+dbus_bool_t _dbus_string_validate_utf8 (const DBusString *str,
+ int start,
+ int len);
+dbus_bool_t _dbus_string_validate_nul (const DBusString *str,
+ int start,
+ int len);
+void _dbus_string_zero (DBusString *str);
-char* _dbus_string_get_data (DBusString *str);
-const char* _dbus_string_get_const_data (const DBusString *str);
-char* _dbus_string_get_data_len (DBusString *str,
- int start,
- int len);
-const char* _dbus_string_get_const_data_len (const DBusString *str,
- int start,
- int len);
-void _dbus_string_set_byte (DBusString *str,
- int i,
- unsigned char byte);
-unsigned char _dbus_string_get_byte (const DBusString *str,
- int start);
-dbus_bool_t _dbus_string_insert_byte (DBusString *str,
- int i,
- unsigned char byte);
-dbus_bool_t _dbus_string_steal_data (DBusString *str,
- char **data_return);
-dbus_bool_t _dbus_string_steal_data_len (DBusString *str,
- char **data_return,
- int start,
- int len);
-dbus_bool_t _dbus_string_copy_data (const DBusString *str,
- char **data_return);
-dbus_bool_t _dbus_string_copy_data_len (const DBusString *str,
- char **data_return,
- int start,
- int len);
-
-int _dbus_string_get_length (const DBusString *str);
-
-dbus_bool_t _dbus_string_lengthen (DBusString *str,
- int additional_length);
-void _dbus_string_shorten (DBusString *str,
- int length_to_remove);
-dbus_bool_t _dbus_string_set_length (DBusString *str,
- int length);
-dbus_bool_t _dbus_string_align_length (DBusString *str,
- int alignment);
-
-dbus_bool_t _dbus_string_append (DBusString *str,
- const char *buffer);
-dbus_bool_t _dbus_string_append_len (DBusString *str,
- const char *buffer,
- int len);
-dbus_bool_t _dbus_string_append_int (DBusString *str,
- long value);
-dbus_bool_t _dbus_string_append_uint (DBusString *str,
- unsigned long value);
-dbus_bool_t _dbus_string_append_double (DBusString *str,
- double value);
-dbus_bool_t _dbus_string_append_byte (DBusString *str,
- unsigned char byte);
-dbus_bool_t _dbus_string_append_unichar (DBusString *str,
- dbus_unichar_t ch);
-
-
-void _dbus_string_delete (DBusString *str,
- int start,
- int len);
-dbus_bool_t _dbus_string_move (DBusString *source,
- int start,
- DBusString *dest,
- int insert_at);
-dbus_bool_t _dbus_string_copy (const DBusString *source,
- int start,
- DBusString *dest,
- int insert_at);
-dbus_bool_t _dbus_string_move_len (DBusString *source,
- int start,
- int len,
- DBusString *dest,
- int insert_at);
-dbus_bool_t _dbus_string_copy_len (const DBusString *source,
- int start,
- int len,
- DBusString *dest,
- int insert_at);
-
-dbus_bool_t _dbus_string_replace_len (const DBusString *source,
- int start,
- int len,
- DBusString *dest,
- int replace_at,
- int replace_len);
-
-void _dbus_string_get_unichar (const DBusString *str,
- int start,
- dbus_unichar_t *ch_return,
- int *end_return);
-
-dbus_bool_t _dbus_string_parse_int (const DBusString *str,
- int start,
- long *value_return,
- int *end_return);
-dbus_bool_t _dbus_string_parse_uint (const DBusString *str,
- int start,
- unsigned long *value_return,
- int *end_return);
-dbus_bool_t _dbus_string_parse_double (const DBusString *str,
- int start,
- double *value,
- int *end_return);
-
-dbus_bool_t _dbus_string_find (const DBusString *str,
- int start,
- const char *substr,
- int *found);
-
-dbus_bool_t _dbus_string_find_to (const DBusString *str,
- int start,
- int end,
- const char *substr,
- int *found);
-dbus_bool_t _dbus_string_find_blank (const DBusString *str,
- int start,
- int *found);
-
-void _dbus_string_skip_blank (const DBusString *str,
- int start,
- int *end);
-
-void _dbus_string_skip_white (const DBusString *str,
- int start,
- int *end);
-
-dbus_bool_t _dbus_string_equal (const DBusString *a,
- const DBusString *b);
-
-dbus_bool_t _dbus_string_equal_c_str (const DBusString *a,
- const char *c_str);
-
-dbus_bool_t _dbus_string_equal_len (const DBusString *a,
- const DBusString *b,
- int len);
-
-dbus_bool_t _dbus_string_starts_with_c_str (const DBusString *a,
- const char *c_str);
-dbus_bool_t _dbus_string_ends_with_c_str (const DBusString *a,
- const char *c_str);
-
-dbus_bool_t _dbus_string_pop_line (DBusString *source,
- DBusString *dest);
-void _dbus_string_delete_first_word (DBusString *str);
-void _dbus_string_delete_leading_blanks (DBusString *str);
-
-
-dbus_bool_t _dbus_string_base64_encode (const DBusString *source,
- int start,
- DBusString *dest,
- int insert_at);
-dbus_bool_t _dbus_string_base64_decode (const DBusString *source,
- int start,
- DBusString *dest,
- int insert_at);
-dbus_bool_t _dbus_string_hex_encode (const DBusString *source,
- int start,
- DBusString *dest,
- int insert_at);
-dbus_bool_t _dbus_string_hex_decode (const DBusString *source,
- int start,
- DBusString *dest,
- int insert_at);
-
-dbus_bool_t _dbus_string_validate_ascii (const DBusString *str,
- int start,
- int len);
-
-dbus_bool_t _dbus_string_validate_utf8 (const DBusString *str,
- int start,
- int len);
-
-dbus_bool_t _dbus_string_validate_nul (const DBusString *str,
- int start,
- int len);
-
-void _dbus_string_zero (DBusString *str);
DBUS_END_DECLS;
#include "dbus-internals.h"
#include "dbus-sysdeps.h"
#include "dbus-threads.h"
+#include "dbus-test.h"
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>
if (fd < 0)
{
dbus_set_error (error, _dbus_error_from_errno (errno),
- "%s", _dbus_strerror (errno));
+ "Failed to open \"%s\": %s",
+ filename_c,
+ _dbus_strerror (errno));
return FALSE;
}
if (fstat (fd, &sb) < 0)
{
dbus_set_error (error, _dbus_error_from_errno (errno),
- "%s", _dbus_strerror (errno));
+ "Failed to stat \"%s\": %s",
+ filename_c,
+ _dbus_strerror (errno));
_dbus_verbose ("fstat() failed: %s",
_dbus_strerror (errno));
if (sb.st_size > _DBUS_ONE_MEGABYTE)
{
dbus_set_error (error, DBUS_ERROR_FAILED,
- "File size %lu is too large.\n",
- (unsigned long) sb.st_size);
+ "File size %lu of \"%s\" is too large.",
+ filename_c, (unsigned long) sb.st_size);
close (fd);
return FALSE;
}
if (bytes_read <= 0)
{
dbus_set_error (error, _dbus_error_from_errno (errno),
- "%s", _dbus_strerror (errno));
+ "Error reading \"%s\": %s",
+ filename_c,
+ _dbus_strerror (errno));
_dbus_verbose ("read() failed: %s",
_dbus_strerror (errno));
{
_dbus_verbose ("Can only open regular files at the moment.\n");
dbus_set_error (error, DBUS_ERROR_FAILED,
- "Not a regular file");
+ "\"%s\" is not a regular file",
+ filename_c);
close (fd);
return FALSE;
}
/**
* Appends the given filename to the given directory.
*
+ * @todo it might be cute to collapse multiple '/' such as "foo//"
+ * concat "//bar"
+ *
* @param dir the directory name
* @param next_component the filename
* @returns #TRUE on success
_dbus_string_get_length (dir));
}
+/**
+ * Get the directory name from a complete filename
+ * @param filename the filename
+ * @param dirname string to append directory name to
+ * @returns #FALSE if no memory
+ */
+dbus_bool_t
+_dbus_string_get_dirname (const DBusString *filename,
+ DBusString *dirname)
+{
+ int sep;
+
+ _dbus_assert (filename != dirname);
+ _dbus_assert (filename != NULL);
+ _dbus_assert (dirname != NULL);
+
+ /* Ignore any separators on the end */
+ sep = _dbus_string_get_length (filename);
+ if (sep == 0)
+ return _dbus_string_append (dirname, "."); /* empty string passed in */
+
+ while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
+ --sep;
+
+ _dbus_assert (sep >= 0);
+
+ if (sep == 0)
+ return _dbus_string_append (dirname, "/");
+
+ /* Now find the previous separator */
+ _dbus_string_find_byte_backward (filename, sep, '/', &sep);
+ if (sep < 0)
+ return _dbus_string_append (dirname, ".");
+
+ /* skip multiple separators */
+ while (sep > 0 && _dbus_string_get_byte (filename, sep - 1) == '/')
+ --sep;
+
+ _dbus_assert (sep >= 0);
+
+ if (sep == 0 &&
+ _dbus_string_get_byte (filename, 0) == '/')
+ return _dbus_string_append (dirname, "/");
+ else
+ return _dbus_string_copy_len (filename, 0, sep - 0,
+ dirname, _dbus_string_get_length (dirname));
+}
+
+/**
+ * Checks whether the filename is an absolute path
+ *
+ * @param filename the filename
+ * @returns #TRUE if an absolute path
+ */
+dbus_bool_t
+_dbus_path_is_absolute (const DBusString *filename)
+{
+ if (_dbus_string_get_length (filename) > 0)
+ return _dbus_string_get_byte (filename, 0) == '/';
+ else
+ return FALSE;
+}
+
struct DBusDirIter
{
DIR *d;
if (d == NULL)
{
dbus_set_error (error, _dbus_error_from_errno (errno),
- "%s", _dbus_strerror (errno));
+ "Failed to read directory \"%s\": %s",
+ filename_c,
+ _dbus_strerror (errno));
return NULL;
}
iter = dbus_new0 (DBusDirIter, 1);
return TRUE;
}
+#ifdef DBUS_BUILD_TESTS
+#include <stdlib.h>
+static void
+check_dirname (const char *filename,
+ const char *dirname)
+{
+ DBusString f, d;
+
+ _dbus_string_init_const (&f, filename);
+
+ if (!_dbus_string_init (&d))
+ _dbus_assert_not_reached ("no memory");
+
+ if (!_dbus_string_get_dirname (&f, &d))
+ _dbus_assert_not_reached ("no memory");
+
+ if (!_dbus_string_equal_c_str (&d, dirname))
+ {
+ _dbus_warn ("For filename \"%s\" got dirname \"%s\" and expected \"%s\"\n",
+ filename,
+ _dbus_string_get_const_data (&d),
+ dirname);
+ exit (1);
+ }
+
+ _dbus_string_free (&d);
+}
+
+static void
+check_path_absolute (const char *path,
+ dbus_bool_t expected)
+{
+ DBusString p;
+
+ _dbus_string_init_const (&p, path);
+
+ if (_dbus_path_is_absolute (&p) != expected)
+ {
+ _dbus_warn ("For path \"%s\" expected absolute = %d got %d\n",
+ path, expected, _dbus_path_is_absolute (&p));
+ exit (1);
+ }
+}
+
+/**
+ * Unit test for dbus-sysdeps.c.
+ *
+ * @returns #TRUE on success.
+ */
+dbus_bool_t
+_dbus_sysdeps_test (void)
+{
+ check_dirname ("foo", ".");
+ check_dirname ("foo/bar", "foo");
+ check_dirname ("foo//bar", "foo");
+ check_dirname ("foo///bar", "foo");
+ check_dirname ("foo/bar/", "foo");
+ check_dirname ("foo//bar/", "foo");
+ check_dirname ("foo///bar/", "foo");
+ check_dirname ("foo/bar//", "foo");
+ check_dirname ("foo//bar////", "foo");
+ check_dirname ("foo///bar///////", "foo");
+ check_dirname ("/foo", "/");
+ check_dirname ("////foo", "/");
+ check_dirname ("/foo/bar", "/foo");
+ check_dirname ("/foo//bar", "/foo");
+ check_dirname ("/foo///bar", "/foo");
+ check_dirname ("/", "/");
+ check_dirname ("///", "/");
+ check_dirname ("", ".");
+
+ check_path_absolute ("/", TRUE);
+ check_path_absolute ("/foo", TRUE);
+ check_path_absolute ("", FALSE);
+ check_path_absolute ("foo", FALSE);
+ check_path_absolute ("foo/bar", FALSE);
+
+ return TRUE;
+}
+#endif /* DBUS_BUILD_TESTS */
+
/** @} end of sysdeps */
+
dbus_bool_t _dbus_concat_dir_and_file (DBusString *dir,
const DBusString *next_component);
+dbus_bool_t _dbus_string_get_dirname (const DBusString *filename,
+ DBusString *dirname);
+dbus_bool_t _dbus_path_is_absolute (const DBusString *filename);
typedef struct DBusDirIter DBusDirIter;
die ("strings");
check_memleaks ();
+
+ printf ("%s: running sysdeps tests\n", "dbus-test");
+ if (!_dbus_sysdeps_test ())
+ die ("sysdeps");
+
+ check_memleaks ();
printf ("%s: running data slot tests\n", "dbus-test");
if (!_dbus_data_slot_test ())
dbus_bool_t _dbus_sha_test (const char *test_data_dir);
dbus_bool_t _dbus_keyring_test (void);
dbus_bool_t _dbus_data_slot_test (void);
+dbus_bool_t _dbus_sysdeps_test (void);
void dbus_internal_do_not_use_run_tests (const char *test_data_dir);
dbus_bool_t dbus_internal_do_not_use_try_message_file (const DBusString *filename,
--- /dev/null
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <user>mybususer</user>
+ <listen>unix:path=/foo/bar</listen>
+ <listen>tcp:port=1234</listen>
+ <includedir>basic.d</includedir>
+ <servicedir>/usr/share/foo</servicedir>
+ <include ignore_missing="yes">nonexistent.conf</include>
+ <policy context="default">
+ <allow user="*"/>
+ </policy>
+</busconfig>
projects / platform / upstream / dbus.git / commitdiff