-/* -*- mode: C; c-file-style: "gnu" -*- */
-/* dbus-string.c String utility class (internal to D-BUS implementation)
+/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
+/* dbus-string.c String utility class (internal to D-Bus implementation)
*
- * Copyright (C) 2002, 2003, 2004 Red Hat, Inc.
+ * Copyright (C) 2002, 2003, 2004, 2005 Red Hat, Inc.
+ * Copyright (C) 2006 Ralf Habacker <ralf.habacker@freenet.de>
*
* Licensed under the Academic Free License version 2.1
*
#include <string.h>
/* for vsnprintf */
#include <stdio.h>
-#include "dbus-marshal.h"
#define DBUS_CAN_USE_DBUS_STRING_PRIVATE 1
#include "dbus-string-private.h"
-#include "dbus-protocol.h"
+#include "dbus-marshal-basic.h" /* probably should be removed by moving the usage of DBUS_TYPE
+ * into the marshaling-related files
+ */
/* for DBUS_VA_COPY */
#include "dbus-sysdeps.h"
/**
- * @defgroup DBusString string class
+ * @defgroup DBusString DBusString class
* @ingroup DBusInternals
- * @brief DBusString data structure
+ * @brief DBusString data structure for safer string handling
*
* Types and functions related to DBusString. DBusString is intended
* to be a string class that makes it hard to mess up security issues
* because it could keep us from detecting bogus huge lengths. i.e. if
* we passed in some bogus huge length it would be taken to mean
* "current length of string" instead of "broken crack"
- */
-
-/**
- * @defgroup DBusStringInternals DBusString implementation details
- * @ingroup DBusInternals
- * @brief DBusString implementation details
- *
- * The guts of DBusString.
- *
- * @{
- */
-
-/**
- * We allocate 1 byte for nul termination, plus 7 bytes for possible
- * align_offset, so we always need 8 bytes on top of the string's
- * length to be in the allocated block.
- */
-#define ALLOCATION_PADDING 8
-
-/**
- * This is the maximum max length (and thus also the maximum length)
- * of a DBusString
- */
-#define MAX_MAX_LENGTH (_DBUS_INT_MAX - ALLOCATION_PADDING)
-
-/**
- * Checks a bunch of assertions about a string object
*
- * @param real the DBusRealString
+ * @todo #DBusString needs a lot of cleaning up; some of the
+ * API is no longer used, and the API is pretty inconsistent.
+ * In particular all the "append" APIs, especially those involving
+ * alignment but probably lots of them, are no longer used by the
+ * marshaling code which always does "inserts" now.
*/
-#define DBUS_GENERIC_STRING_PREAMBLE(real) _dbus_assert ((real) != NULL); _dbus_assert (!(real)->invalid); _dbus_assert ((real)->len >= 0); _dbus_assert ((real)->allocated >= 0); _dbus_assert ((real)->max_length >= 0); _dbus_assert ((real)->len <= ((real)->allocated - ALLOCATION_PADDING)); _dbus_assert ((real)->len <= (real)->max_length)
-
-/**
- * Checks assertions about a string object that needs to be
- * modifiable - may not be locked or const. Also declares
- * the "real" variable pointing to DBusRealString.
- * @param str the string
- */
-#define DBUS_STRING_PREAMBLE(str) DBusRealString *real = (DBusRealString*) str; \
- DBUS_GENERIC_STRING_PREAMBLE (real); \
- _dbus_assert (!(real)->constant); \
- _dbus_assert (!(real)->locked)
-
-/**
- * Checks assertions about a string object that may be locked but
- * can't be const. i.e. a string object that we can free. Also
- * declares the "real" variable pointing to DBusRealString.
- *
- * @param str the string
- */
-#define DBUS_LOCKED_STRING_PREAMBLE(str) DBusRealString *real = (DBusRealString*) str; \
- DBUS_GENERIC_STRING_PREAMBLE (real); \
- _dbus_assert (!(real)->constant)
-
-/**
- * Checks assertions about a string that may be const or locked. Also
- * declares the "real" variable pointing to DBusRealString.
- * @param str the string.
- */
-#define DBUS_CONST_STRING_PREAMBLE(str) const DBusRealString *real = (DBusRealString*) str; \
- DBUS_GENERIC_STRING_PREAMBLE (real)
-
-/** @} */
/**
* @addtogroup DBusString
static void
fixup_alignment (DBusRealString *real)
{
- char *aligned;
- char *real_block;
+ unsigned char *aligned;
+ unsigned char *real_block;
unsigned int old_align_offset;
/* we have to have extra space in real->allocated for the align offset and nul byte */
- _dbus_assert (real->len <= real->allocated - ALLOCATION_PADDING);
+ _dbus_assert (real->len <= real->allocated - _DBUS_STRING_ALLOCATION_PADDING);
old_align_offset = real->align_offset;
real_block = real->str - old_align_offset;
* an existing string, e.g. in _dbus_string_steal_data()
*/
- real->str = dbus_malloc (ALLOCATION_PADDING + allocate_size);
+ real->str = dbus_malloc (_DBUS_STRING_ALLOCATION_PADDING + allocate_size);
if (real->str == NULL)
return FALSE;
- real->allocated = ALLOCATION_PADDING + allocate_size;
+ real->allocated = _DBUS_STRING_ALLOCATION_PADDING + allocate_size;
real->len = 0;
real->str[real->len] = '\0';
- real->max_length = MAX_MAX_LENGTH;
+ real->max_length = _DBUS_STRING_MAX_MAX_LENGTH;
real->constant = FALSE;
real->locked = FALSE;
real->invalid = FALSE;
return _dbus_string_init_preallocated (str, 0);
}
+#ifdef DBUS_BUILD_TESTS
/* The max length thing is sort of a historical artifact
* from a feature that turned out to be dumb; perhaps
* we should purge it entirely. The problem with
real->max_length = max_length;
}
+#endif /* DBUS_BUILD_TESTS */
/**
* Initializes a constant string. The value parameter is not copied
DBusRealString *real;
_dbus_assert (str != NULL);
- _dbus_assert (value != NULL);
- _dbus_assert (len <= MAX_MAX_LENGTH);
+ _dbus_assert (len == 0 || value != NULL);
+ _dbus_assert (len <= _DBUS_STRING_MAX_MAX_LENGTH);
_dbus_assert (len >= 0);
real = (DBusRealString*) str;
- real->str = (char*) value;
+ real->str = (unsigned char*) value;
real->len = len;
- real->allocated = real->len + ALLOCATION_PADDING; /* a lie, just to avoid special-case assertions... */
+ real->allocated = real->len + _DBUS_STRING_ALLOCATION_PADDING; /* a lie, just to avoid special-case assertions... */
real->max_length = real->len + 1;
real->constant = TRUE;
+ real->locked = TRUE;
real->invalid = FALSE;
+ real->align_offset = 0;
/* We don't require const strings to be 8-byte aligned as the
* memory is coming from elsewhere.
real->invalid = TRUE;
}
+static dbus_bool_t
+compact (DBusRealString *real,
+ int max_waste)
+{
+ unsigned char *new_str;
+ int new_allocated;
+ int waste;
+
+ waste = real->allocated - (real->len + _DBUS_STRING_ALLOCATION_PADDING);
+
+ if (waste <= max_waste)
+ return TRUE;
+
+ new_allocated = real->len + _DBUS_STRING_ALLOCATION_PADDING;
+
+ new_str = dbus_realloc (real->str - real->align_offset, new_allocated);
+ if (_DBUS_UNLIKELY (new_str == NULL))
+ return FALSE;
+
+ real->str = new_str + real->align_offset;
+ real->allocated = new_allocated;
+ fixup_alignment (real);
+
+ return TRUE;
+}
+
#ifdef DBUS_BUILD_TESTS
/* Not using this feature at the moment,
* so marked DBUS_BUILD_TESTS-only
* we know we won't change the string further
*/
#define MAX_WASTE 48
- if (real->allocated - MAX_WASTE > real->len)
- {
- char *new_str;
- int new_allocated;
-
- new_allocated = real->len + ALLOCATION_PADDING;
-
- new_str = dbus_realloc (real->str - real->align_offset,
- new_allocated);
- if (new_str != NULL)
- {
- real->str = new_str + real->align_offset;
- real->allocated = new_allocated;
- fixup_alignment (real);
- }
- }
+ compact (real, MAX_WASTE);
}
#endif /* DBUS_BUILD_TESTS */
int new_length)
{
int new_allocated;
- char *new_str;
+ unsigned char *new_str;
/* at least double our old allocation to avoid O(n), avoiding
* overflow
*/
- if (real->allocated > (MAX_MAX_LENGTH + ALLOCATION_PADDING) / 2)
- new_allocated = MAX_MAX_LENGTH + ALLOCATION_PADDING;
+ if (real->allocated > (_DBUS_STRING_MAX_MAX_LENGTH + _DBUS_STRING_ALLOCATION_PADDING) / 2)
+ new_allocated = _DBUS_STRING_MAX_MAX_LENGTH + _DBUS_STRING_ALLOCATION_PADDING;
else
new_allocated = real->allocated * 2;
/* But be sure we always alloc at least space for the new length */
new_allocated = MAX (new_allocated,
- new_length + ALLOCATION_PADDING);
+ new_length + _DBUS_STRING_ALLOCATION_PADDING);
_dbus_assert (new_allocated >= real->allocated); /* code relies on this */
new_str = dbus_realloc (real->str - real->align_offset, new_allocated);
return TRUE;
}
+/**
+ * Compacts the string to avoid wasted memory. Wasted memory is
+ * memory that is allocated but not actually required to store the
+ * current length of the string. The compact is only done if more
+ * than the given amount of memory is being wasted (otherwise the
+ * waste is ignored and the call does nothing).
+ *
+ * @param str the string
+ * @param max_waste the maximum amount of waste to ignore
+ * @returns #FALSE if the compact failed due to realloc failure
+ */
+dbus_bool_t
+_dbus_string_compact (DBusString *str,
+ int max_waste)
+{
+ DBUS_STRING_PREAMBLE (str);
+
+ return compact (real, max_waste);
+}
+
static dbus_bool_t
set_length (DBusRealString *real,
int new_length)
/* exceeding max length is the same as failure to allocate memory */
if (_DBUS_UNLIKELY (new_length > real->max_length))
return FALSE;
- else if (new_length > (real->allocated - ALLOCATION_PADDING) &&
+ else if (new_length > (real->allocated - _DBUS_STRING_ALLOCATION_PADDING) &&
_DBUS_UNLIKELY (!reallocate_for_length (real, new_length)))
return FALSE;
else
return TRUE;
}
+#ifndef _dbus_string_get_data
/**
* Gets the raw character buffer from the string. The returned buffer
* will be nul-terminated, but note that strings may contain binary
{
DBUS_STRING_PREAMBLE (str);
- return real->str;
+ return (char*) real->str;
}
+#endif /* _dbus_string_get_data */
/* only do the function if we don't have the macro */
#ifndef _dbus_string_get_const_data
{
DBUS_CONST_STRING_PREAMBLE (str);
- return real->str;
+ return (const char*) real->str;
}
#endif /* _dbus_string_get_const_data */
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
- return real->str + start;
+ return (char*) real->str + start;
}
+/* only do the function if we don't have the macro */
+#ifndef _dbus_string_get_const_data_len
/**
* const version of _dbus_string_get_data_len().
*
_dbus_assert (start <= real->len);
_dbus_assert (len <= real->len - start);
- return real->str + start;
+ return (const char*) real->str + start;
}
+#endif /* _dbus_string_get_const_data_len */
+/* only do the function if we don't have the macro */
+#ifndef _dbus_string_set_byte
/**
* Sets the value of the byte at the given position.
*
real->str[i] = byte;
}
+#endif /* _dbus_string_set_byte */
/* only have the function if we didn't create a macro */
#ifndef _dbus_string_get_byte
undo_alignment (real);
- *data_return = real->str;
+ *data_return = (char*) real->str;
old_max_length = real->max_length;
if (!_dbus_string_init (str))
{
/* hrm, put it back then */
- real->str = *data_return;
+ real->str = (unsigned char*) *data_return;
*data_return = NULL;
fixup_alignment (real);
return FALSE;
return TRUE;
}
+#ifdef DBUS_BUILD_TESTS
/**
* Like _dbus_string_get_data_len(), but removes the gotten data from
* the original string. The caller must free the data returned. This
_dbus_string_free (&dest);
return TRUE;
}
-
+#endif /* DBUS_BUILD_TESTS */
/**
* Copies the data from the string into a char*
}
/**
+ * Copies the contents of a DBusString into a different
+ * buffer. The resulting buffer will be nul-terminated.
+ *
+ * @param str a string
+ * @param buffer a C buffer to copy data to
+ * @param avail_len maximum length of C buffer
+ */
+void
+_dbus_string_copy_to_buffer (const DBusString *str,
+ char *buffer,
+ int avail_len)
+{
+ int copy_len;
+ DBUS_CONST_STRING_PREAMBLE (str);
+
+ _dbus_assert (avail_len >= 0);
+
+ copy_len = MIN (avail_len, real->len+1);
+ memcpy (buffer, real->str, copy_len);
+ if (avail_len > 0 && avail_len == copy_len)
+ buffer[avail_len-1] = '\0';
+}
+
+#ifdef DBUS_BUILD_TESTS
+/**
* Copies a segment of the string into a char*
*
* @param str the string
_dbus_string_free (&dest);
return TRUE;
}
-
-/**
- * Copies the contents of a DBusString into a different
- * buffer. The resulting buffer will be nul-terminated.
- *
- * @param str a string
- * @param buffer a C buffer to copy data to
- * @param len maximum length of C buffer
- */
-void
-_dbus_string_copy_to_buffer (const DBusString *str,
- char *buffer,
- int avail_len)
-{
- int copy_len;
- DBUS_CONST_STRING_PREAMBLE (str);
-
- _dbus_assert (avail_len >= 0);
-
- copy_len = MIN (avail_len, real->len+1);
- memcpy (buffer, real->str, copy_len);
- if (avail_len > 0 && avail_len == copy_len)
- buffer[avail_len-1] = '\0';
-}
+#endif /* DBUS_BUILD_TESTS */
/* Only have the function if we don't have the macro */
#ifndef _dbus_string_get_length
return append (real, buffer, buffer_len);
}
+/** assign 2 bytes from one string to another */
+#define ASSIGN_2_OCTETS(p, octets) \
+ *((dbus_uint16_t*)(p)) = *((dbus_uint16_t*)(octets));
+
+/** assign 4 bytes from one string to another */
#define ASSIGN_4_OCTETS(p, octets) \
*((dbus_uint32_t*)(p)) = *((dbus_uint32_t*)(octets));
#ifdef DBUS_HAVE_INT64
+/** assign 8 bytes from one string to another */
#define ASSIGN_8_OCTETS(p, octets) \
*((dbus_uint64_t*)(p)) = *((dbus_uint64_t*)(octets));
#else
+/** assign 8 bytes from one string to another */
#define ASSIGN_8_OCTETS(p, octets) \
do { \
unsigned char *b; \
} while (0)
#endif /* DBUS_HAVE_INT64 */
+#ifdef DBUS_BUILD_TESTS
/**
* Appends 4 bytes aligned on a 4 byte boundary
* with any alignment padding initialized to 0.
return TRUE;
}
+#endif /* DBUS_BUILD_TESTS */
+#ifdef DBUS_BUILD_TESTS
/**
* Appends 8 bytes aligned on an 8 byte boundary
* with any alignment padding initialized to 0.
return TRUE;
}
+#endif /* DBUS_BUILD_TESTS */
+
+/**
+ * Inserts 2 bytes aligned on a 2 byte boundary
+ * with any alignment padding initialized to 0.
+ *
+ * @param str the DBusString
+ * @param insert_at where to insert
+ * @param octets 2 bytes to insert
+ * @returns #FALSE if not enough memory.
+ */
+dbus_bool_t
+_dbus_string_insert_2_aligned (DBusString *str,
+ int insert_at,
+ const unsigned char octets[4])
+{
+ DBUS_STRING_PREAMBLE (str);
+
+ if (!align_insert_point_then_open_gap (str, &insert_at, 2, 2))
+ return FALSE;
+
+ ASSIGN_2_OCTETS (real->str + insert_at, octets);
+
+ return TRUE;
+}
/**
* Inserts 4 bytes aligned on a 4 byte boundary
* with any alignment padding initialized to 0.
*
* @param str the DBusString
+ * @param insert_at where to insert
* @param octets 4 bytes to insert
* @returns #FALSE if not enough memory.
*/
* with any alignment padding initialized to 0.
*
* @param str the DBusString
+ * @param insert_at where to insert
* @param octets 8 bytes to insert
* @returns #FALSE if not enough memory.
*/
return TRUE;
}
+
+/**
+ * Inserts padding at *insert_at such to align it to the given
+ * boundary. Initializes the padding to nul bytes. Sets *insert_at
+ * to the aligned position.
+ *
+ * @param str the DBusString
+ * @param insert_at location to be aligned
+ * @param alignment alignment boundary (1, 2, 4, or 8)
+ * @returns #FALSE if not enough memory.
+ */
+dbus_bool_t
+_dbus_string_insert_alignment (DBusString *str,
+ int *insert_at,
+ int alignment)
+{
+ DBUS_STRING_PREAMBLE (str);
+
+ if (!align_insert_point_then_open_gap (str, insert_at, alignment, 0))
+ return FALSE;
+
+ _dbus_assert (_DBUS_ALIGN_VALUE (*insert_at, alignment) == (unsigned) *insert_at);
+
+ return TRUE;
+}
+
/**
* Appends a printf-style formatted string
* to the #DBusString.
va_list args)
{
int len;
- char c;
va_list args_copy;
DBUS_STRING_PREAMBLE (str);
DBUS_VA_COPY (args_copy, args);
/* Measure the message length without terminating nul */
- len = vsnprintf (&c, 1, format, args);
+ len = _dbus_printf_string_upper_bound (format, args);
if (!_dbus_string_lengthen (str, len))
{
return FALSE;
}
- vsprintf (real->str + (real->len - len),
+ vsprintf ((char*) (real->str + (real->len - len)),
format, args_copy);
va_end (args_copy);
return TRUE;
}
+#ifdef DBUS_BUILD_TESTS
/**
* Appends a single Unicode character, encoding the character
* in UTF-8 format.
int len;
int first;
int i;
- char *out;
+ unsigned char *out;
DBUS_STRING_PREAMBLE (str);
return TRUE;
}
+#endif /* DBUS_BUILD_TESTS */
static void
delete (DBusRealString *real,
if (!open_gap (len, dest, insert_at))
return FALSE;
- memcpy (dest->str + insert_at,
- source->str + start,
- len);
+ memmove (dest->str + insert_at,
+ source->str + start,
+ len);
return TRUE;
}
((Char) < 0xFDD0 || (Char) > 0xFDEF) && \
((Char) & 0xFFFF) != 0xFFFF)
+#ifdef DBUS_BUILD_TESTS
/**
* Gets a unicode character from a UTF-8 string. Does no validation;
* you must verify that the string is valid UTF-8 in advance and must
if (end_return)
*end_return = start + len;
}
+#endif /* DBUS_BUILD_TESTS */
/**
* Finds the given substring in the string,
}
/**
+ * Finds end of line ("\r\n" or "\n") in the string,
+ * returning #TRUE and filling in the byte index
+ * where the eol string was found, if it was found.
+ * Returns #FALSE if eol wasn't found.
+ *
+ * @param str the string
+ * @param start where to start looking
+ * @param found return location for where eol was found or string length otherwise
+ * @param found_len return length of found eol string or zero otherwise
+ * @returns #TRUE if found
+ */
+dbus_bool_t
+_dbus_string_find_eol (const DBusString *str,
+ int start,
+ int *found,
+ int *found_len)
+{
+ int i;
+
+ DBUS_CONST_STRING_PREAMBLE (str);
+ _dbus_assert (start <= real->len);
+ _dbus_assert (start >= 0);
+
+ i = start;
+ while (i < real->len)
+ {
+ if (real->str[i] == '\r')
+ {
+ if ((i+1) < real->len && real->str[i+1] == '\n') /* "\r\n" */
+ {
+ if (found)
+ *found = i;
+ if (found_len)
+ *found_len = 2;
+ return TRUE;
+ }
+ else /* only "\r" */
+ {
+ if (found)
+ *found = i;
+ if (found_len)
+ *found_len = 1;
+ return TRUE;
+ }
+ }
+ else if (real->str[i] == '\n') /* only "\n" */
+ {
+ if (found)
+ *found = i;
+ if (found_len)
+ *found_len = 1;
+ return TRUE;
+ }
+ ++i;
+ }
+
+ if (found)
+ *found = real->len;
+
+ if (found_len)
+ *found_len = 0;
+
+ return FALSE;
+}
+
+/**
* Finds the given substring in the string,
* up to a certain position,
* returning #TRUE and filling in the byte index
}
/**
- * 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 start the place to start scanning (will not find the byte at this point)
- * @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.
i = start;
while (i < real->len)
{
- if (!(real->str[i] == ' ' ||
- real->str[i] == '\t'))
+ if (!DBUS_IS_ASCII_BLANK (real->str[i]))
break;
++i;
}
- _dbus_assert (i == real->len || !(real->str[i] == ' ' ||
- real->str[i] == '\t'));
+ _dbus_assert (i == real->len || !DBUS_IS_ASCII_WHITE (real->str[i]));
if (end)
*end = i;
}
+
/**
* Skips whitespace from start, storing the first non-whitespace in *end.
* (whitespace is space, tab, newline, CR).
i = start;
while (i < real->len)
{
- if (!(real->str[i] == ' ' ||
- real->str[i] == '\n' ||
- real->str[i] == '\r' ||
- real->str[i] == '\t'))
+ if (!DBUS_IS_ASCII_WHITE (real->str[i]))
break;
++i;
}
- _dbus_assert (i == real->len || !(real->str[i] == ' ' ||
- real->str[i] == '\t'));
+ _dbus_assert (i == real->len || !(DBUS_IS_ASCII_WHITE (real->str[i])));
if (end)
*end = i;
}
/**
+ * Skips whitespace from end, storing the start index of the trailing
+ * whitespace in *start. (whitespace is space, tab, newline, CR).
+ *
+ * @param str the string
+ * @param end where to start scanning backward
+ * @param start where to store the start of whitespace chars
+ */
+void
+_dbus_string_skip_white_reverse (const DBusString *str,
+ int end,
+ int *start)
+{
+ int i;
+ DBUS_CONST_STRING_PREAMBLE (str);
+ _dbus_assert (end <= real->len);
+ _dbus_assert (end >= 0);
+
+ i = end;
+ while (i > 0)
+ {
+ if (!DBUS_IS_ASCII_WHITE (real->str[i-1]))
+ break;
+ --i;
+ }
+
+ _dbus_assert (i >= 0 && (i == 0 || !(DBUS_IS_ASCII_WHITE (real->str[i-1]))));
+
+ if (start)
+ *start = i;
+}
+
+/**
* Assigns a newline-terminated or \\r\\n-terminated line from the front
* of the string to the given dest string. The dest string's previous
* contents are deleted. If the source string contains no newline,
* @todo owen correctly notes that this is a stupid function (it was
* written purely for test code,
* e.g. dbus-message-builder.c). Probably should be enforced as test
- * code only with #ifdef DBUS_BUILD_TESTS
+ * code only with ifdef DBUS_BUILD_TESTS
*
* @param source the source string
* @param dest the destination string (contents are replaced)
_dbus_string_pop_line (DBusString *source,
DBusString *dest)
{
- int eol;
- dbus_bool_t have_newline;
+ int eol, eol_len;
_dbus_string_set_length (dest, 0);
eol = 0;
- if (_dbus_string_find (source, 0, "\n", &eol))
- {
- have_newline = TRUE;
- eol += 1; /* include newline */
- }
- else
+ eol_len = 0;
+ if (!_dbus_string_find_eol (source, 0, &eol, &eol_len))
{
- eol = _dbus_string_get_length (source);
- have_newline = FALSE;
+ _dbus_assert (eol == _dbus_string_get_length (source));
+ if (eol == 0)
+ {
+ /* If there's no newline and source has zero length, we're done */
+ return FALSE;
+ }
+ /* otherwise, the last line of the file has no eol characters */
}
- if (eol == 0)
- return FALSE; /* eof */
+ /* remember eol can be 0 if it's an empty line, but eol_len should not be zero also
+ * since find_eol returned TRUE
+ */
- if (!_dbus_string_move_len (source, 0, eol,
- dest, 0))
+ if (!_dbus_string_move_len (source, 0, eol + eol_len, dest, 0))
+ return FALSE;
+
+ /* remove line ending */
+ if (!_dbus_string_set_length (dest, eol))
{
+ _dbus_assert_not_reached ("out of memory when shortening a string");
return FALSE;
}
- /* dump the newline and the \r if we have one */
- if (have_newline)
- {
- dbus_bool_t have_cr;
-
- _dbus_assert (_dbus_string_get_length (dest) > 0);
-
- if (_dbus_string_get_length (dest) > 1 &&
- _dbus_string_get_byte (dest,
- _dbus_string_get_length (dest) - 2) == '\r')
- have_cr = TRUE;
- else
- have_cr = FALSE;
-
- _dbus_string_set_length (dest,
- _dbus_string_get_length (dest) -
- (have_cr ? 2 : 1));
- }
-
return TRUE;
}
+#ifdef DBUS_BUILD_TESTS
/**
* Deletes up to and including the first blank space
* in the string.
_dbus_string_delete (str, 0, i);
}
+#endif
+#ifdef DBUS_BUILD_TESTS
/**
* Deletes any leading blanks in the string
*
if (i > 0)
_dbus_string_delete (str, 0, i);
}
+#endif
+
+/**
+ * Deletes leading and trailing whitespace
+ *
+ * @param str the string
+ */
+void
+_dbus_string_chop_white(DBusString *str)
+{
+ int i;
+
+ _dbus_string_skip_white (str, 0, &i);
+
+ if (i > 0)
+ _dbus_string_delete (str, 0, i);
+
+ _dbus_string_skip_white_reverse (str, _dbus_string_get_length (str), &i);
+
+ _dbus_string_set_length (str, i);
+}
/**
* Tests two DBusString for equality.
return TRUE;
}
+#ifdef DBUS_BUILD_TESTS
/**
* Tests two DBusString for equality up to the given length.
* The strings may be shorter than the given length.
return TRUE;
}
+#endif /* DBUS_BUILD_TESTS */
/**
* Tests two sub-parts of two DBusString for equality. The specified
return TRUE;
}
+#ifdef DBUS_BUILD_TESTS
/**
* Checks whether a string starts with the given C string.
*
else
return FALSE;
}
+#endif /* DBUS_BUILD_TESTS */
/**
- * Returns whether a string ends with the given suffix
+ * Appends a two-character hex digit to a string, where the hex digit
+ * has the value of the given byte.
*
- * @todo memcmp might make this faster.
- *
- * @param a the string
- * @param c_str the C-style string
- * @returns #TRUE if the string ends with the suffix
+ * @param str the string
+ * @param byte the byte
+ * @returns #FALSE if no memory
*/
dbus_bool_t
-_dbus_string_ends_with_c_str (const DBusString *a,
- const char *c_str)
+_dbus_string_append_byte_as_hex (DBusString *str,
+ int byte)
{
- const unsigned char *ap;
- const unsigned char *bp;
- const unsigned char *a_end;
- unsigned long c_str_len;
- const DBusRealString *real_a = (const DBusRealString*) a;
- DBUS_GENERIC_STRING_PREAMBLE (real_a);
- _dbus_assert (c_str != NULL);
-
- c_str_len = strlen (c_str);
- if (((unsigned long)real_a->len) < c_str_len)
+ const char hexdigits[16] = {
+ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+ 'a', 'b', 'c', 'd', 'e', 'f'
+ };
+
+ if (!_dbus_string_append_byte (str,
+ hexdigits[(byte >> 4)]))
return FALSE;
- ap = real_a->str + (real_a->len - c_str_len);
- bp = (const unsigned char*) c_str;
- a_end = real_a->str + real_a->len;
- while (ap != a_end)
+ if (!_dbus_string_append_byte (str,
+ hexdigits[(byte & 0x0f)]))
{
- if (*ap != *bp)
- return FALSE;
-
- ++ap;
- ++bp;
+ _dbus_string_set_length (str,
+ _dbus_string_get_length (str) - 1);
+ return FALSE;
}
- _dbus_assert (*ap == '\0');
- _dbus_assert (*bp == '\0');
-
return TRUE;
}
int insert_at)
{
DBusString result;
- const char hexdigits[16] = {
- '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
- 'a', 'b', 'c', 'd', 'e', 'f'
- };
const unsigned char *p;
const unsigned char *end;
dbus_bool_t retval;
while (p != end)
{
- if (!_dbus_string_append_byte (&result,
- hexdigits[(*p >> 4)]))
+ if (!_dbus_string_append_byte_as_hex (&result, *p))
goto out;
- if (!_dbus_string_append_byte (&result,
- hexdigits[(*p & 0x0f)]))
- goto out;
-
++p;
}
_dbus_assert (len >= 0);
/* we are doing _DBUS_UNLIKELY() here which might be
- * dubious in a generic library like GLib, but in D-BUS
+ * dubious in a generic library like GLib, but in D-Bus
* we know we're validating messages and that it would
* only be evil/broken apps that would have invalid
* UTF-8. Also, this function seems to be a performance
break;
/* Special-case ASCII; this makes us go a lot faster in
- * D-BUS profiles where we are typically validating
+ * D-Bus profiles where we are typically validating
* function names and such. We have to know that
* all following checks will pass for ASCII though,
* comments follow ...
}
/**
- * Checks that the given range of the string is a valid object path
- * name in the D-BUS protocol. This includes a length restriction,
- * etc., see the specification. It does not validate UTF-8, that has
- * to be done separately for now.
- *
- * @todo this is inconsistent with most of DBusString in that
- * it allows a start,len range that extends past the string end.
- *
- * @todo change spec to disallow more things, such as spaces in the
- * path name
- *
- * @param str the string
- * @param start first byte index to check
- * @param len number of bytes to check
- * @returns #TRUE if the byte range exists and is a valid name
- */
-dbus_bool_t
-_dbus_string_validate_path (const DBusString *str,
- int start,
- int len)
-{
- const unsigned char *s;
- const unsigned char *end;
- const unsigned char *last_slash;
-
- DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (start >= 0);
- _dbus_assert (len >= 0);
- _dbus_assert (start <= real->len);
-
- if (len > real->len - start)
- return FALSE;
-
- if (len > DBUS_MAXIMUM_NAME_LENGTH)
- return FALSE;
-
- if (len == 0)
- return FALSE;
-
- s = real->str + start;
- end = s + len;
-
- if (*s != '/')
- return FALSE;
- last_slash = s;
- ++s;
-
- while (s != end)
- {
- if (*s == '/')
- {
- if ((s - last_slash) < 2)
- return FALSE; /* no empty path components allowed */
-
- last_slash = s;
- }
-
- ++s;
- }
-
- if ((end - last_slash) < 2 &&
- len > 1)
- return FALSE; /* trailing slash not allowed unless the string is "/" */
-
- return TRUE;
-}
-
-/**
- * Determine wether the given charater is valid as the first charater
- * in a name.
- */
-#define VALID_INITIAL_NAME_CHARACTER(c) \
- ( ((c) >= 'A' && (c) <= 'Z') || \
- ((c) >= 'a' && (c) <= 'z') || \
- ((c) == '_') )
-
-/**
- * Determine wether the given charater is valid as a second or later
- * character in a nam
- */
-#define VALID_NAME_CHARACTER(c) \
- ( ((c) >= '0' && (c) <= '9') || \
- ((c) >= 'A' && (c) <= 'Z') || \
- ((c) >= 'a' && (c) <= 'z') || \
- ((c) == '_') )
-
-/**
- * Checks that the given range of the string is a valid interface name
- * in the D-BUS protocol. This includes a length restriction and an
- * ASCII subset, see the specification.
- *
- * @todo this is inconsistent with most of DBusString in that
- * it allows a start,len range that extends past the string end.
- *
- * @param str the string
- * @param start first byte index to check
- * @param len number of bytes to check
- * @returns #TRUE if the byte range exists and is a valid name
- */
-dbus_bool_t
-_dbus_string_validate_interface (const DBusString *str,
- int start,
- int len)
-{
- const unsigned char *s;
- const unsigned char *end;
- const unsigned char *iface;
- const unsigned char *last_dot;
-
- DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (start >= 0);
- _dbus_assert (len >= 0);
- _dbus_assert (start <= real->len);
-
- if (len > real->len - start)
- return FALSE;
-
- if (len > DBUS_MAXIMUM_NAME_LENGTH)
- return FALSE;
-
- if (len == 0)
- return FALSE;
-
- last_dot = NULL;
- iface = real->str + start;
- end = iface + len;
- s = iface;
-
- /* check special cases of first char so it doesn't have to be done
- * in the loop. Note we know len > 0
- */
- if (_DBUS_UNLIKELY (*s == '.')) /* disallow starting with a . */
- return FALSE;
- else if (_DBUS_UNLIKELY (!VALID_INITIAL_NAME_CHARACTER (*s)))
- return FALSE;
- else
- ++s;
-
- while (s != end)
- {
- if (*s == '.')
- {
- if (_DBUS_UNLIKELY ((s + 1) == end))
- return FALSE;
- else if (_DBUS_UNLIKELY (!VALID_INITIAL_NAME_CHARACTER (*(s + 1))))
- return FALSE;
- last_dot = s;
- ++s; /* we just validated the next char, so skip two */
- }
- else if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*s)))
- {
- return FALSE;
- }
-
- ++s;
- }
-
- if (_DBUS_UNLIKELY (last_dot == NULL))
- return FALSE;
-
- return TRUE;
-}
-
-/**
- * Checks that the given range of the string is a valid member name
- * in the D-BUS protocol. This includes a length restriction, etc.,
- * see the specification.
- *
- * @todo this is inconsistent with most of DBusString in that
- * it allows a start,len range that extends past the string end.
- *
- * @param str the string
- * @param start first byte index to check
- * @param len number of bytes to check
- * @returns #TRUE if the byte range exists and is a valid name
- */
-dbus_bool_t
-_dbus_string_validate_member (const DBusString *str,
- int start,
- int len)
-{
- const unsigned char *s;
- const unsigned char *end;
- const unsigned char *member;
-
- DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (start >= 0);
- _dbus_assert (len >= 0);
- _dbus_assert (start <= real->len);
-
- if (len > real->len - start)
- return FALSE;
-
- if (len > DBUS_MAXIMUM_NAME_LENGTH)
- return FALSE;
-
- if (len == 0)
- return FALSE;
-
- member = real->str + start;
- end = member + len;
- s = member;
-
- /* check special cases of first char so it doesn't have to be done
- * in the loop. Note we know len > 0
- */
-
- if (_DBUS_UNLIKELY (!VALID_INITIAL_NAME_CHARACTER (*s)))
- return FALSE;
- else
- ++s;
-
- while (s != end)
- {
- if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*s)))
- {
- return FALSE;
- }
-
- ++s;
- }
-
- return TRUE;
-}
-
-/**
- * Checks that the given range of the string is a valid error name
- * in the D-BUS protocol. This includes a length restriction, etc.,
- * see the specification.
+ * Clears all allocated bytes in the string to zero.
*
- * @todo this is inconsistent with most of DBusString in that
- * it allows a start,len range that extends past the string end.
- *
* @param str the string
- * @param start first byte index to check
- * @param len number of bytes to check
- * @returns #TRUE if the byte range exists and is a valid name
*/
-dbus_bool_t
-_dbus_string_validate_error_name (const DBusString *str,
- int start,
- int len)
-{
- /* Same restrictions as interface name at the moment */
- return _dbus_string_validate_interface (str, start, len);
-}
-
-/* This assumes the first char exists and is ':' */
-static dbus_bool_t
-_dbus_string_validate_base_service (const DBusString *str,
- int start,
- int len)
+void
+_dbus_string_zero (DBusString *str)
{
- const unsigned char *s;
- const unsigned char *end;
- const unsigned char *service;
-
- DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (start >= 0);
- _dbus_assert (len >= 0);
- _dbus_assert (start <= real->len);
-
- if (len > real->len - start)
- return FALSE;
-
- if (len > DBUS_MAXIMUM_NAME_LENGTH)
- return FALSE;
-
- _dbus_assert (len > 0);
+ DBUS_STRING_PREAMBLE (str);
- service = real->str + start;
- end = service + len;
- _dbus_assert (*service == ':');
- s = service + 1;
-
- while (s != end)
- {
- if (*s == '.')
- {
- if (_DBUS_UNLIKELY ((s + 1) == end))
- return FALSE;
- if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*(s + 1))))
- return FALSE;
- ++s; /* we just validated the next char, so skip two */
- }
- else if (_DBUS_UNLIKELY (!VALID_NAME_CHARACTER (*s)))
- {
- return FALSE;
- }
-
- ++s;
- }
-
- return TRUE;
+ memset (real->str - real->align_offset, '\0', real->allocated);
}
+/** @} */
-/**
- * Checks that the given range of the string is a valid service name
- * in the D-BUS protocol. This includes a length restriction, etc.,
- * see the specification.
- *
- * @todo this is inconsistent with most of DBusString in that
- * it allows a start,len range that extends past the string end.
- *
- * @param str the string
- * @param start first byte index to check
- * @param len number of bytes to check
- * @returns #TRUE if the byte range exists and is a valid name
- */
-dbus_bool_t
-_dbus_string_validate_service (const DBusString *str,
- int start,
- int len)
-{
- if (_DBUS_UNLIKELY (len == 0))
- return FALSE;
- if (_dbus_string_get_byte (str, start) == ':')
- return _dbus_string_validate_base_service (str, start, len);
- else
- return _dbus_string_validate_interface (str, start, len);
-}
-
-/**
- * Checks that the given range of the string is a valid message type
- * signature in the D-BUS protocol.
- *
- * @todo this is inconsistent with most of DBusString in that
- * it allows a start,len range that extends past the string end.
- *
- * @param str the string
- * @param start first byte index to check
- * @param len number of bytes to check
- * @returns #TRUE if the byte range exists and is a valid signature
- */
-dbus_bool_t
-_dbus_string_validate_signature (const DBusString *str,
- int start,
- int len)
-{
- const unsigned char *s;
- const unsigned char *end;
- DBUS_CONST_STRING_PREAMBLE (str);
- _dbus_assert (start >= 0);
- _dbus_assert (start <= real->len);
- _dbus_assert (len >= 0);
-
- if (len > real->len - start)
- return FALSE;
-
- s = real->str + start;
- end = s + len;
- while (s != end)
- {
- switch (*s)
- {
- case DBUS_TYPE_NIL:
- case DBUS_TYPE_BYTE:
- case DBUS_TYPE_BOOLEAN:
- case DBUS_TYPE_INT32:
- case DBUS_TYPE_UINT32:
- case DBUS_TYPE_INT64:
- case DBUS_TYPE_UINT64:
- case DBUS_TYPE_DOUBLE:
- case DBUS_TYPE_STRING:
- case DBUS_TYPE_CUSTOM:
- case DBUS_TYPE_ARRAY:
- case DBUS_TYPE_DICT:
- case DBUS_TYPE_OBJECT_PATH:
- break;
-
- default:
- return FALSE;
- }
-
- ++s;
- }
-
- return TRUE;
-}
-
-/**
- * Clears all allocated bytes in the string to zero.
- *
- * @param str the string
- */
-void
-_dbus_string_zero (DBusString *str)
-{
- DBUS_STRING_PREAMBLE (str);
-
- memset (real->str - real->align_offset, '\0', real->allocated);
-}
-/** @} */
-
-#ifdef DBUS_BUILD_TESTS
-#include "dbus-test.h"
-#include <stdio.h>
-
-/**
- * Parses a basic type defined by type contained in a DBusString. The
- * end_return parameter may be #NULL if you aren't interested in it. The
- * type is parsed and stored in value_return. Return parameters are not
- * initialized if the function returns #FALSE.
- *
- * @param str the string
- * @param type the type of the basic type
- * @param start the byte index of the start of the type
- * @param value_return return location of the value or #NULL
- * @param end_return return location of the end of the type, or #NULL
- * @returns #TRUE on success
- */
-dbus_bool_t
-_dbus_string_parse_basic_type (const DBusString *str,
- char type,
- int start,
- void *value,
- int *end_return)
-{
- int end = start;
-
- switch (type)
- {
- case DBUS_TYPE_BOOLEAN:
- {
- int len = _dbus_string_get_length (str) - start;
- if (len >= 5 && _dbus_string_find_to (str, start, start + 5, "false", NULL))
- {
- end += 5;
- *(unsigned char *) value = TRUE;
- }
- else if (len >= 4 && _dbus_string_find_to (str, start, start + 4, "true", NULL))
- {
- end += 4;
- *(unsigned char *) value = FALSE;
- }
- else
- _dbus_warn ("could not parse BOOLEAN\n");
- break;
- }
- case DBUS_TYPE_BYTE:
- {
- long val = 0;
-
- if (_dbus_string_get_byte (str, start) == '\'' &&
- _dbus_string_get_length (str) >= start + 4 &&
- _dbus_string_get_byte (str, start + 1) == '\\' &&
- _dbus_string_get_byte (str, start + 2) == '\'' &&
- _dbus_string_get_byte (str, start + 3) == '\'')
- {
- val = '\'';
- end += 4;
- }
- else if (_dbus_string_get_byte (str, start) == '\'' &&
- _dbus_string_get_length (str) >= start + 3 &&
- _dbus_string_get_byte (str, start + 2) == '\'')
- {
- val = _dbus_string_get_byte (str, start + 1);
- end += 3;
- }
- else
- {
- if (!_dbus_string_parse_int (str, start, &val, &end))
- _dbus_warn ("Failed to parse integer for BYTE\n");
- }
-
- if (val > 255)
- _dbus_warn ("A byte must be in range 0-255 not %ld\n", val);
-
- *(unsigned char *) value = val;
- break;
- }
- case DBUS_TYPE_INT32:
- {
- long val;
- if (_dbus_string_parse_int (str, start, &val, &end))
- *(dbus_int32_t *)value = val;
- break;
- }
- case DBUS_TYPE_UINT32:
- {
- unsigned long val;
- if (_dbus_string_parse_uint (str, start, &val, &end))
- *(dbus_uint32_t *)value = val;
- break;
- }
-#ifdef DBUS_HAVE_INT64
- case DBUS_TYPE_INT64:
- case DBUS_TYPE_UINT64:
- /* use stroll oull */
- _dbus_assert_not_reached ("string -> [u]int64 not supported yet");
- break;
-#endif /* DBUS_HAVE_INT64 */
- case DBUS_TYPE_DOUBLE:
- _dbus_string_parse_double (str, start, value, &end);
- break;
- default:
- _dbus_assert_not_reached ("not a basic type");
- break;
- }
- if (end_return)
- *end_return = end;
-
- return end != start;
-}
-
-static void
-test_max_len (DBusString *str,
- int max_len)
-{
- if (max_len > 0)
- {
- if (!_dbus_string_set_length (str, max_len - 1))
- _dbus_assert_not_reached ("setting len to one less than max should have worked");
- }
-
- if (!_dbus_string_set_length (str, max_len))
- _dbus_assert_not_reached ("setting len to max len should have worked");
-
- if (_dbus_string_set_length (str, max_len + 1))
- _dbus_assert_not_reached ("setting len to one more than max len should not have worked");
-
- if (!_dbus_string_set_length (str, 0))
- _dbus_assert_not_reached ("setting len to zero should have worked");
-}
-
-static void
-test_hex_roundtrip (const unsigned char *data,
- int len)
-{
- DBusString orig;
- DBusString encoded;
- DBusString decoded;
- int end;
-
- if (len < 0)
- len = strlen (data);
-
- if (!_dbus_string_init (&orig))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_init (&encoded))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_init (&decoded))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_append_len (&orig, data, len))
- _dbus_assert_not_reached ("couldn't append orig data");
-
- if (!_dbus_string_hex_encode (&orig, 0, &encoded, 0))
- _dbus_assert_not_reached ("could not encode");
-
- if (!_dbus_string_hex_decode (&encoded, 0, &end, &decoded, 0))
- _dbus_assert_not_reached ("could not decode");
-
- _dbus_assert (_dbus_string_get_length (&encoded) == end);
-
- if (!_dbus_string_equal (&orig, &decoded))
- {
- const char *s;
-
- printf ("Original string %d bytes encoded %d bytes decoded %d bytes\n",
- _dbus_string_get_length (&orig),
- _dbus_string_get_length (&encoded),
- _dbus_string_get_length (&decoded));
- printf ("Original: %s\n", data);
- s = _dbus_string_get_const_data (&decoded);
- printf ("Decoded: %s\n", s);
- _dbus_assert_not_reached ("original string not the same as string decoded from hex");
- }
-
- _dbus_string_free (&orig);
- _dbus_string_free (&encoded);
- _dbus_string_free (&decoded);
-}
-
-typedef void (* TestRoundtripFunc) (const unsigned char *data,
- int len);
-static void
-test_roundtrips (TestRoundtripFunc func)
-{
- (* func) ("Hello this is a string\n", -1);
- (* func) ("Hello this is a string\n1", -1);
- (* func) ("Hello this is a string\n12", -1);
- (* func) ("Hello this is a string\n123", -1);
- (* func) ("Hello this is a string\n1234", -1);
- (* func) ("Hello this is a string\n12345", -1);
- (* func) ("", 0);
- (* func) ("1", 1);
- (* func) ("12", 2);
- (* func) ("123", 3);
- (* func) ("1234", 4);
- (* func) ("12345", 5);
- (* func) ("", 1);
- (* func) ("1", 2);
- (* func) ("12", 3);
- (* func) ("123", 4);
- (* func) ("1234", 5);
- (* func) ("12345", 6);
- {
- unsigned char buf[512];
- int i;
-
- i = 0;
- while (i < _DBUS_N_ELEMENTS (buf))
- {
- buf[i] = i;
- ++i;
- }
- i = 0;
- while (i < _DBUS_N_ELEMENTS (buf))
- {
- (* func) (buf, i);
- ++i;
- }
- }
-}
-
-
-/**
- * @ingroup DBusStringInternals
- * Unit test for DBusString.
- *
- * @todo Need to write tests for _dbus_string_copy() and
- * _dbus_string_move() moving to/from each of start/middle/end of a
- * string. Also need tests for _dbus_string_move_len ()
- *
- * @returns #TRUE on success.
- */
-dbus_bool_t
-_dbus_string_test (void)
-{
- DBusString str;
- DBusString other;
- int i, end;
- long v;
- double d;
- int lens[] = { 0, 1, 2, 3, 4, 5, 10, 16, 17, 18, 25, 31, 32, 33, 34, 35, 63, 64, 65, 66, 67, 68, 69, 70, 71, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136 };
- char *s;
- dbus_unichar_t ch;
- const char *valid_paths[] = {
- "/",
- "/foo/bar",
- "/foo",
- "/foo/bar/baz"
- };
- const char *invalid_paths[] = {
- "bar",
- "bar/baz",
- "/foo/bar/",
- "/foo/"
- "foo/",
- "boo//blah",
- "//",
- "///",
- "foo///blah/",
- "Hello World",
- "",
- " ",
- "foo bar"
- };
-
- const char *valid_interfaces[] = {
- "org.freedesktop.Foo",
- "Bar.Baz",
- "Blah.Blah.Blah.Blah.Blah",
- "a.b",
- "a.b.c.d.e.f.g",
- "a0.b1.c2.d3.e4.f5.g6",
- "abc123.foo27"
- };
- const char *invalid_interfaces[] = {
- ".",
- "",
- "..",
- ".Foo.Bar",
- "..Foo.Bar",
- "Foo.Bar.",
- "Foo.Bar..",
- "Foo",
- "9foo.bar.baz",
- "foo.bar..baz",
- "foo.bar...baz",
- "foo.bar.b..blah",
- ":",
- ":0-1",
- "10",
- ":11.34324",
- "0.0.0",
- "0..0",
- "foo.Bar.%",
- "foo.Bar!!",
- "!Foo.bar.bz",
- "foo.$.blah",
- "",
- " ",
- "foo bar"
- };
-
- const char *valid_base_services[] = {
- ":0",
- ":a",
- ":",
- ":.a",
- ":.1",
- ":0.1",
- ":000.2222",
- ":.blah",
- ":abce.freedesktop.blah"
- };
- const char *invalid_base_services[] = {
- ":-",
- ":!",
- ":0-10",
- ":blah.",
- ":blah.",
- ":blah..org",
- ":blah.org..",
- ":..blah.org",
- "",
- " ",
- "foo bar"
- };
-
- const char *valid_members[] = {
- "Hello",
- "Bar",
- "foobar",
- "_foobar",
- "foo89"
- };
-
- const char *invalid_members[] = {
- "9Hello",
- "10",
- "1",
- "foo-bar",
- "blah.org",
- ".blah",
- "blah.",
- "Hello.",
- "!foo",
- "",
- " ",
- "foo bar"
- };
-
- const char *valid_signatures[] = {
- "",
- "sss",
- "i",
- "b"
- };
-
- const char *invalid_signatures[] = {
- " ",
- "not a valid signature",
- "123",
- ".",
- "("
- };
-
- i = 0;
- while (i < _DBUS_N_ELEMENTS (lens))
- {
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- set_max_length (&str, lens[i]);
-
- test_max_len (&str, lens[i]);
- _dbus_string_free (&str);
-
- ++i;
- }
-
- /* Test shortening and setting length */
- i = 0;
- while (i < _DBUS_N_ELEMENTS (lens))
- {
- int j;
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- set_max_length (&str, lens[i]);
-
- if (!_dbus_string_set_length (&str, lens[i]))
- _dbus_assert_not_reached ("failed to set string length");
-
- j = lens[i];
- while (j > 0)
- {
- _dbus_assert (_dbus_string_get_length (&str) == j);
- if (j > 0)
- {
- _dbus_string_shorten (&str, 1);
- _dbus_assert (_dbus_string_get_length (&str) == (j - 1));
- }
- --j;
- }
-
- _dbus_string_free (&str);
-
- ++i;
- }
-
- /* Test appending data */
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- i = 0;
- while (i < 10)
- {
- if (!_dbus_string_append (&str, "a"))
- _dbus_assert_not_reached ("failed to append string to string\n");
-
- _dbus_assert (_dbus_string_get_length (&str) == i * 2 + 1);
-
- if (!_dbus_string_append_byte (&str, 'b'))
- _dbus_assert_not_reached ("failed to append byte to string\n");
-
- _dbus_assert (_dbus_string_get_length (&str) == i * 2 + 2);
-
- ++i;
- }
-
- _dbus_string_free (&str);
-
- /* Check steal_data */
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
-
- i = _dbus_string_get_length (&str);
-
- if (!_dbus_string_steal_data (&str, &s))
- _dbus_assert_not_reached ("failed to steal data");
-
- _dbus_assert (_dbus_string_get_length (&str) == 0);
- _dbus_assert (((int)strlen (s)) == i);
-
- dbus_free (s);
-
- /* Check move */
-
- if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
-
- i = _dbus_string_get_length (&str);
-
- if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_move (&str, 0, &other, 0))
- _dbus_assert_not_reached ("could not move");
-
- _dbus_assert (_dbus_string_get_length (&str) == 0);
- _dbus_assert (_dbus_string_get_length (&other) == i);
-
- if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
-
- if (!_dbus_string_move (&str, 0, &other, _dbus_string_get_length (&other)))
- _dbus_assert_not_reached ("could not move");
-
- _dbus_assert (_dbus_string_get_length (&str) == 0);
- _dbus_assert (_dbus_string_get_length (&other) == i * 2);
-
- if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
-
- if (!_dbus_string_move (&str, 0, &other, _dbus_string_get_length (&other) / 2))
- _dbus_assert_not_reached ("could not move");
-
- _dbus_assert (_dbus_string_get_length (&str) == 0);
- _dbus_assert (_dbus_string_get_length (&other) == i * 3);
-
- _dbus_string_free (&other);
-
- /* Check copy */
-
- if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
-
- i = _dbus_string_get_length (&str);
-
- if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_copy (&str, 0, &other, 0))
- _dbus_assert_not_reached ("could not copy");
-
- _dbus_assert (_dbus_string_get_length (&str) == i);
- _dbus_assert (_dbus_string_get_length (&other) == i);
-
- if (!_dbus_string_copy (&str, 0, &other, _dbus_string_get_length (&other)))
- _dbus_assert_not_reached ("could not copy");
-
- _dbus_assert (_dbus_string_get_length (&str) == i);
- _dbus_assert (_dbus_string_get_length (&other) == i * 2);
- _dbus_assert (_dbus_string_equal_c_str (&other,
- "Hello WorldHello World"));
-
- if (!_dbus_string_copy (&str, 0, &other, _dbus_string_get_length (&other) / 2))
- _dbus_assert_not_reached ("could not copy");
-
- _dbus_assert (_dbus_string_get_length (&str) == i);
- _dbus_assert (_dbus_string_get_length (&other) == i * 3);
- _dbus_assert (_dbus_string_equal_c_str (&other,
- "Hello WorldHello WorldHello World"));
-
- _dbus_string_free (&str);
- _dbus_string_free (&other);
-
- /* Check replace */
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- if (!_dbus_string_append (&str, "Hello World"))
- _dbus_assert_not_reached ("could not append to string");
-
- i = _dbus_string_get_length (&str);
-
- if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
- &other, 0, _dbus_string_get_length (&other)))
- _dbus_assert_not_reached ("could not replace");
-
- _dbus_assert (_dbus_string_get_length (&str) == i);
- _dbus_assert (_dbus_string_get_length (&other) == i);
- _dbus_assert (_dbus_string_equal_c_str (&other, "Hello World"));
-
- if (!_dbus_string_replace_len (&str, 0, _dbus_string_get_length (&str),
- &other, 5, 1))
- _dbus_assert_not_reached ("could not replace center space");
-
- _dbus_assert (_dbus_string_get_length (&str) == i);
- _dbus_assert (_dbus_string_get_length (&other) == i * 2 - 1);
- _dbus_assert (_dbus_string_equal_c_str (&other,
- "HelloHello WorldWorld"));
-
-
- if (!_dbus_string_replace_len (&str, 1, 1,
- &other,
- _dbus_string_get_length (&other) - 1,
- 1))
- _dbus_assert_not_reached ("could not replace end character");
-
- _dbus_assert (_dbus_string_get_length (&str) == i);
- _dbus_assert (_dbus_string_get_length (&other) == i * 2 - 1);
- _dbus_assert (_dbus_string_equal_c_str (&other,
- "HelloHello WorldWorle"));
-
- _dbus_string_free (&str);
- _dbus_string_free (&other);
-
- /* Check append/get unichar */
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- ch = 0;
- if (!_dbus_string_append_unichar (&str, 0xfffc))
- _dbus_assert_not_reached ("failed to append unichar");
-
- _dbus_string_get_unichar (&str, 0, &ch, &i);
-
- _dbus_assert (ch == 0xfffc);
- _dbus_assert (i == _dbus_string_get_length (&str));
-
- _dbus_string_free (&str);
-
- /* Check insert/set/get byte */
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- if (!_dbus_string_append (&str, "Hello"))
- _dbus_assert_not_reached ("failed to append Hello");
-
- _dbus_assert (_dbus_string_get_byte (&str, 0) == 'H');
- _dbus_assert (_dbus_string_get_byte (&str, 1) == 'e');
- _dbus_assert (_dbus_string_get_byte (&str, 2) == 'l');
- _dbus_assert (_dbus_string_get_byte (&str, 3) == 'l');
- _dbus_assert (_dbus_string_get_byte (&str, 4) == 'o');
-
- _dbus_string_set_byte (&str, 1, 'q');
- _dbus_assert (_dbus_string_get_byte (&str, 1) == 'q');
-
- if (!_dbus_string_insert_bytes (&str, 0, 1, 255))
- _dbus_assert_not_reached ("can't insert byte");
-
- if (!_dbus_string_insert_bytes (&str, 2, 4, 'Z'))
- _dbus_assert_not_reached ("can't insert byte");
-
- if (!_dbus_string_insert_bytes (&str, _dbus_string_get_length (&str), 1, 'W'))
- _dbus_assert_not_reached ("can't insert byte");
-
- _dbus_assert (_dbus_string_get_byte (&str, 0) == 255);
- _dbus_assert (_dbus_string_get_byte (&str, 1) == 'H');
- _dbus_assert (_dbus_string_get_byte (&str, 2) == 'Z');
- _dbus_assert (_dbus_string_get_byte (&str, 3) == 'Z');
- _dbus_assert (_dbus_string_get_byte (&str, 4) == 'Z');
- _dbus_assert (_dbus_string_get_byte (&str, 5) == 'Z');
- _dbus_assert (_dbus_string_get_byte (&str, 6) == 'q');
- _dbus_assert (_dbus_string_get_byte (&str, 7) == 'l');
- _dbus_assert (_dbus_string_get_byte (&str, 8) == 'l');
- _dbus_assert (_dbus_string_get_byte (&str, 9) == 'o');
- _dbus_assert (_dbus_string_get_byte (&str, 10) == 'W');
-
- _dbus_string_free (&str);
-
- /* Check append/parse int/double */
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- if (!_dbus_string_append_int (&str, 27))
- _dbus_assert_not_reached ("failed to append int");
-
- i = _dbus_string_get_length (&str);
-
- if (!_dbus_string_parse_int (&str, 0, &v, &end))
- _dbus_assert_not_reached ("failed to parse int");
-
- _dbus_assert (v == 27);
- _dbus_assert (end == i);
-
- _dbus_string_free (&str);
-
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- if (!_dbus_string_append_double (&str, 50.3))
- _dbus_assert_not_reached ("failed to append float");
-
- i = _dbus_string_get_length (&str);
-
- if (!_dbus_string_parse_double (&str, 0, &d, &end))
- _dbus_assert_not_reached ("failed to parse float");
-
- _dbus_assert (d > (50.3 - 1e-6) && d < (50.3 + 1e-6));
- _dbus_assert (end == i);
-
- _dbus_string_free (&str);
-
- /* Test find */
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("failed to init string");
-
- if (!_dbus_string_append (&str, "Hello"))
- _dbus_assert_not_reached ("couldn't append to string");
-
- if (!_dbus_string_find (&str, 0, "He", &i))
- _dbus_assert_not_reached ("didn't find 'He'");
- _dbus_assert (i == 0);
-
- if (!_dbus_string_find (&str, 0, "Hello", &i))
- _dbus_assert_not_reached ("didn't find 'Hello'");
- _dbus_assert (i == 0);
-
- if (!_dbus_string_find (&str, 0, "ello", &i))
- _dbus_assert_not_reached ("didn't find 'ello'");
- _dbus_assert (i == 1);
-
- if (!_dbus_string_find (&str, 0, "lo", &i))
- _dbus_assert_not_reached ("didn't find 'lo'");
- _dbus_assert (i == 3);
-
- if (!_dbus_string_find (&str, 2, "lo", &i))
- _dbus_assert_not_reached ("didn't find 'lo'");
- _dbus_assert (i == 3);
-
- if (_dbus_string_find (&str, 4, "lo", &i))
- _dbus_assert_not_reached ("did find 'lo'");
-
- if (!_dbus_string_find (&str, 0, "l", &i))
- _dbus_assert_not_reached ("didn't find 'l'");
- _dbus_assert (i == 2);
-
- if (!_dbus_string_find (&str, 0, "H", &i))
- _dbus_assert_not_reached ("didn't find 'H'");
- _dbus_assert (i == 0);
-
- if (!_dbus_string_find (&str, 0, "", &i))
- _dbus_assert_not_reached ("didn't find ''");
- _dbus_assert (i == 0);
-
- if (_dbus_string_find (&str, 0, "Hello!", NULL))
- _dbus_assert_not_reached ("Did find 'Hello!'");
-
- if (_dbus_string_find (&str, 0, "Oh, Hello", NULL))
- _dbus_assert_not_reached ("Did find 'Oh, Hello'");
-
- if (_dbus_string_find (&str, 0, "ill", NULL))
- _dbus_assert_not_reached ("Did find 'ill'");
-
- if (_dbus_string_find (&str, 0, "q", NULL))
- _dbus_assert_not_reached ("Did find 'q'");
-
- if (!_dbus_string_find_to (&str, 0, 2, "He", NULL))
- _dbus_assert_not_reached ("Didn't find 'He'");
-
- 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);
-
- /* Hex encoding */
- _dbus_string_init_const (&str, "cafebabe, this is a bogus hex string");
- if (!_dbus_string_init (&other))
- _dbus_assert_not_reached ("could not init string");
-
- if (!_dbus_string_hex_decode (&str, 0, &end, &other, 0))
- _dbus_assert_not_reached ("deccoded bogus hex string with no error");
-
- _dbus_assert (end == 8);
-
- _dbus_string_free (&other);
-
- test_roundtrips (test_hex_roundtrip);
-
- /* Path validation */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_paths))
- {
- _dbus_string_init_const (&str, valid_paths[i]);
-
- if (!_dbus_string_validate_path (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Path \"%s\" should have been valid\n", valid_paths[i]);
- _dbus_assert_not_reached ("invalid path");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_paths))
- {
- _dbus_string_init_const (&str, invalid_paths[i]);
-
- if (_dbus_string_validate_path (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Path \"%s\" should have been invalid\n", invalid_paths[i]);
- _dbus_assert_not_reached ("valid path");
- }
-
- ++i;
- }
-
- /* Interface validation */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_interfaces))
- {
- _dbus_string_init_const (&str, valid_interfaces[i]);
-
- if (!_dbus_string_validate_interface (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Interface \"%s\" should have been valid\n", valid_interfaces[i]);
- _dbus_assert_not_reached ("invalid interface");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_interfaces))
- {
- _dbus_string_init_const (&str, invalid_interfaces[i]);
-
- if (_dbus_string_validate_interface (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Interface \"%s\" should have been invalid\n", invalid_interfaces[i]);
- _dbus_assert_not_reached ("valid interface");
- }
-
- ++i;
- }
-
- /* Service validation (check that valid interfaces are valid services,
- * and invalid interfaces are invalid services except if they start with ':')
- */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_interfaces))
- {
- _dbus_string_init_const (&str, valid_interfaces[i]);
-
- if (!_dbus_string_validate_service (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Service \"%s\" should have been valid\n", valid_interfaces[i]);
- _dbus_assert_not_reached ("invalid service");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_interfaces))
- {
- if (invalid_interfaces[i][0] != ':')
- {
- _dbus_string_init_const (&str, invalid_interfaces[i]);
-
- if (_dbus_string_validate_service (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Service \"%s\" should have been invalid\n", invalid_interfaces[i]);
- _dbus_assert_not_reached ("valid service");
- }
- }
-
- ++i;
- }
-
- /* Base service validation */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_base_services))
- {
- _dbus_string_init_const (&str, valid_base_services[i]);
-
- if (!_dbus_string_validate_service (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Service \"%s\" should have been valid\n", valid_base_services[i]);
- _dbus_assert_not_reached ("invalid base service");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_base_services))
- {
- _dbus_string_init_const (&str, invalid_base_services[i]);
-
- if (_dbus_string_validate_service (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Service \"%s\" should have been invalid\n", invalid_base_services[i]);
- _dbus_assert_not_reached ("valid base service");
- }
-
- ++i;
- }
-
-
- /* Error name validation (currently identical to interfaces)
- */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_interfaces))
- {
- _dbus_string_init_const (&str, valid_interfaces[i]);
-
- if (!_dbus_string_validate_error_name (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Error name \"%s\" should have been valid\n", valid_interfaces[i]);
- _dbus_assert_not_reached ("invalid error name");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_interfaces))
- {
- if (invalid_interfaces[i][0] != ':')
- {
- _dbus_string_init_const (&str, invalid_interfaces[i]);
-
- if (_dbus_string_validate_error_name (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Error name \"%s\" should have been invalid\n", invalid_interfaces[i]);
- _dbus_assert_not_reached ("valid error name");
- }
- }
-
- ++i;
- }
-
- /* Member validation */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_members))
- {
- _dbus_string_init_const (&str, valid_members[i]);
-
- if (!_dbus_string_validate_member (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Member \"%s\" should have been valid\n", valid_members[i]);
- _dbus_assert_not_reached ("invalid member");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_members))
- {
- _dbus_string_init_const (&str, invalid_members[i]);
-
- if (_dbus_string_validate_member (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Member \"%s\" should have been invalid\n", invalid_members[i]);
- _dbus_assert_not_reached ("valid member");
- }
-
- ++i;
- }
-
- /* Signature validation */
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (valid_signatures))
- {
- _dbus_string_init_const (&str, valid_signatures[i]);
-
- if (!_dbus_string_validate_signature (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Signature \"%s\" should have been valid\n", valid_signatures[i]);
- _dbus_assert_not_reached ("invalid signature");
- }
-
- ++i;
- }
-
- i = 0;
- while (i < (int) _DBUS_N_ELEMENTS (invalid_signatures))
- {
- _dbus_string_init_const (&str, invalid_signatures[i]);
-
- if (_dbus_string_validate_signature (&str, 0,
- _dbus_string_get_length (&str)))
- {
- _dbus_warn ("Signature \"%s\" should have been invalid\n", invalid_signatures[i]);
- _dbus_assert_not_reached ("valid signature");
- }
-
- ++i;
- }
-
- /* Validate claimed length longer than real length */
- _dbus_string_init_const (&str, "abc.efg");
- if (_dbus_string_validate_service (&str, 0, 8))
- _dbus_assert_not_reached ("validated too-long string");
- if (_dbus_string_validate_interface (&str, 0, 8))
- _dbus_assert_not_reached ("validated too-long string");
- if (_dbus_string_validate_error_name (&str, 0, 8))
- _dbus_assert_not_reached ("validated too-long string");
-
- _dbus_string_init_const (&str, "abc");
- if (_dbus_string_validate_member (&str, 0, 4))
- _dbus_assert_not_reached ("validated too-long string");
-
- _dbus_string_init_const (&str, "sss");
- if (_dbus_string_validate_signature (&str, 0, 4))
- _dbus_assert_not_reached ("validated too-long signature");
-
- /* Validate string exceeding max name length */
- if (!_dbus_string_init (&str))
- _dbus_assert_not_reached ("no memory");
-
- while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
- if (!_dbus_string_append (&str, "abc.def"))
- _dbus_assert_not_reached ("no memory");
-
- if (_dbus_string_validate_service (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
- if (_dbus_string_validate_interface (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
- if (_dbus_string_validate_error_name (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
-
- /* overlong member */
- _dbus_string_set_length (&str, 0);
- while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
- if (!_dbus_string_append (&str, "abc"))
- _dbus_assert_not_reached ("no memory");
-
- if (_dbus_string_validate_member (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
-
- /* overlong base service */
- _dbus_string_set_length (&str, 0);
- _dbus_string_append (&str, ":");
- while (_dbus_string_get_length (&str) <= DBUS_MAXIMUM_NAME_LENGTH)
- if (!_dbus_string_append (&str, "abc"))
- _dbus_assert_not_reached ("no memory");
-
- if (_dbus_string_validate_service (&str, 0, _dbus_string_get_length (&str)))
- _dbus_assert_not_reached ("validated overmax string");
-
- _dbus_string_free (&str);
-
- return TRUE;
-}
-
-#endif /* DBUS_BUILD_TESTS */
+/* tests are in dbus-string-util.c */
projects / platform / upstream / dbus.git / blobdiff