33 #include "dbus-internals.h"
34 #include "dbus-string.h"
39 #define DBUS_CAN_USE_DBUS_STRING_PRIVATE 1
40 #include "dbus-string-private.h"
41 #include "dbus-marshal-basic.h"
45 #include "dbus-sysdeps.h"
88 unsigned char *aligned;
89 unsigned char *real_block;
90 unsigned int old_align_offset;
96 real_block = real->
str - old_align_offset;
98 aligned = _DBUS_ALIGN_ADDRESS (real_block, 8);
107 real_block + old_align_offset,
156 real->
str =
dbus_malloc (_DBUS_STRING_ALLOCATION_PADDING + allocate_size);
160 real->
allocated = _DBUS_STRING_ALLOCATION_PADDING + allocate_size;
162 real->
str[real->
len] =
'\0';
169 fixup_alignment (real);
230 real->
str = (
unsigned char*) value;
232 real->
allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING;
314 unsigned char *new_str;
318 waste = real->
allocated - (real->
len + _DBUS_STRING_ALLOCATION_PADDING);
320 if (waste <= max_waste)
323 new_allocated = real->
len + _DBUS_STRING_ALLOCATION_PADDING;
326 if (_DBUS_UNLIKELY (new_str ==
NULL))
331 fixup_alignment (real);
336 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
360 compact (real, MAX_WASTE);
369 unsigned char *new_str;
386 #if defined (DBUS_ENABLE_EMBEDDED_TESTS) && !defined (DBUS_DISABLE_ASSERT)
393 new_allocated = MAX (new_allocated,
394 new_length + _DBUS_STRING_ALLOCATION_PADDING);
398 if (_DBUS_UNLIKELY (new_str ==
NULL))
403 fixup_alignment (real);
425 return compact (real, max_waste);
437 else if (new_length > (real->
allocated - _DBUS_STRING_ALLOCATION_PADDING) &&
438 _DBUS_UNLIKELY (!reallocate_for_length (real, new_length)))
442 real->
len = new_length;
443 real->
str[new_length] =
'\0';
459 if (!set_length (dest, dest->
len + len))
462 memmove (dest->
str + insert_at + len,
463 dest->
str + insert_at,
464 dest->
len - len - insert_at);
469 #ifndef _dbus_string_get_data
486 return (
char*) real->
str;
491 #ifndef _dbus_string_get_const_data
499 _dbus_string_get_const_data (
const DBusString *str)
503 return (
const char*) real->
str;
531 return (
char*) real->
str + start;
535 #ifndef _dbus_string_get_const_data_len
545 _dbus_string_get_const_data_len (
const DBusString *str,
555 return (
const char*) real->
str + start;
560 #ifndef _dbus_string_set_byte
582 #ifndef _dbus_string_get_byte
600 return real->
str[start];
628 if (!open_gap (n_bytes, real, i))
631 memset (real->
str + i, byte, n_bytes);
653 if (!open_gap (1, real, i))
678 undo_alignment (real);
680 *data_return = (
char*) real->
str;
686 real->
str = (
unsigned char*) *data_return;
688 fixup_alignment (real);
710 if (*data_return ==
NULL)
713 memcpy (*data_return, real->
str, real->
len + 1);
737 memcpy (buffer, real->
str, real->
len);
759 memcpy (buffer, real->
str, real->
len+1);
763 #ifndef _dbus_string_get_length
770 _dbus_string_get_length (
const DBusString *str)
792 int additional_length)
800 return set_length (real,
801 real->
len + additional_length);
812 int length_to_remove)
819 real->
len - length_to_remove);
839 return set_length (real, length);
843 align_insert_point_then_open_gap (
DBusString *str,
848 unsigned long new_len;
849 unsigned long gap_pos;
856 insert_at = *insert_at_p;
860 gap_pos = _DBUS_ALIGN_VALUE (insert_at, alignment);
861 new_len = real->
len + (gap_pos - insert_at) + gap_size;
866 delta = new_len - real->
len;
871 _dbus_assert (((
unsigned long) *insert_at_p) == gap_pos);
875 if (_DBUS_UNLIKELY (!open_gap (new_len - real->
len,
880 if (gap_size < delta)
882 memset (&real->
str[insert_at],
'\0',
883 gap_pos - insert_at);
886 *insert_at_p = gap_pos;
894 int then_lengthen_by)
898 insert_at = _dbus_string_get_length (str);
900 return align_insert_point_then_open_gap (str,
902 alignment, then_lengthen_by);
917 return align_length_then_lengthen (str, alignment, 0);
951 memcpy (real->
str + (real->
len - buffer_len),
969 unsigned long buffer_len;
974 buffer_len = strlen (buffer);
975 if (buffer_len > (
unsigned long) _DBUS_STRING_MAX_LENGTH)
978 return append (real, buffer, buffer_len);
982 #define ASSIGN_2_OCTETS(p, octets) \
983 *((dbus_uint16_t*)(p)) = *((dbus_uint16_t*)(octets));
986 #define ASSIGN_4_OCTETS(p, octets) \
987 *((dbus_uint32_t*)(p)) = *((dbus_uint32_t*)(octets));
990 #define ASSIGN_8_OCTETS(p, octets) \
991 *((dbus_uint64_t*)(p)) = *((dbus_uint64_t*)(octets));
1005 const unsigned char octets[2])
1009 if (!align_insert_point_then_open_gap (str, &insert_at, 2, 2))
1029 const unsigned char octets[4])
1033 if (!align_insert_point_then_open_gap (str, &insert_at, 4, 4))
1053 const unsigned char octets[8])
1057 if (!align_insert_point_then_open_gap (str, &insert_at, 8, 8))
1060 _dbus_assert (_DBUS_ALIGN_VALUE (insert_at, 8) == (
unsigned) insert_at);
1085 if (!align_insert_point_then_open_gap (str, insert_at, alignment, 0))
1088 _dbus_assert (_DBUS_ALIGN_VALUE (*insert_at, alignment) == (
unsigned) *insert_at);
1113 DBUS_VA_COPY (args_copy, args);
1126 vsprintf ((
char*) (real->
str + (real->
len - len)),
1152 va_start (args, format);
1176 return append (real, buffer, len);
1193 if (!set_length (real, real->
len + 1))
1196 real->
str[real->
len-1] = byte;
1215 if (strings ==
NULL)
1218 for (i = 0; strings[i]; i++)
1238 memmove (real->
str + start, real->
str + start + len, real->
len - (start + len));
1240 real->
str[real->
len] =
'\0';
1263 delete (real, start, len);
1276 if (!open_gap (len, dest, insert_at))
1279 memmove (dest->
str + insert_at,
1280 source->
str + start,
1295 #define DBUS_STRING_COPY_PREAMBLE(source, start, dest, insert_at) \
1296 DBusRealString *real_source = (DBusRealString*) source; \
1297 DBusRealString *real_dest = (DBusRealString*) dest; \
1298 _dbus_assert ((source) != (dest)); \
1299 DBUS_GENERIC_STRING_PREAMBLE (real_source); \
1300 DBUS_GENERIC_STRING_PREAMBLE (real_dest); \
1301 _dbus_assert (!real_dest->constant); \
1302 _dbus_assert (!real_dest->locked); \
1303 _dbus_assert ((start) >= 0); \
1304 _dbus_assert ((start) <= real_source->len); \
1305 _dbus_assert ((insert_at) >= 0); \
1306 _dbus_assert ((insert_at) <= real_dest->len)
1328 real_source->
len - start,
1350 return copy (real_source, start,
1351 real_source->len - start,
1384 else if (start == 0 &&
1385 len == real_source->len &&
1386 real_dest->len == 0)
1394 #define ASSIGN_DATA(a, b) do { \
1395 (a)->str = (b)->str; \
1396 (a)->len = (b)->len; \
1397 (a)->allocated = (b)->allocated; \
1398 (a)->align_offset = (b)->align_offset; \
1403 ASSIGN_DATA (&tmp, real_source);
1404 ASSIGN_DATA (real_source, real_dest);
1405 ASSIGN_DATA (real_dest, &tmp);
1411 if (!copy (real_source, start, len,
1416 delete (real_source, start,
1446 return copy (real_source, start, len,
1477 _dbus_assert (replace_len <= real_dest->len - replace_at);
1479 if (len == replace_len)
1481 memmove (real_dest->str + replace_at,
1482 real_source->str + start, len);
1484 else if (len < replace_len)
1486 memmove (real_dest->str + replace_at,
1487 real_source->str + start, len);
1488 delete (real_dest, replace_at + len,
1497 diff = len - replace_len;
1503 if (!copy (real_source, start + replace_len, diff,
1504 real_dest, replace_at + replace_len))
1507 memmove (real_dest->str + replace_at,
1508 real_source->str + start, replace_len);
1532 char byte_string[2] =
"";
1536 byte_string[0] = (char) byte;
1541 head_length = byte_position;
1542 tail_length = _dbus_string_get_length (source) - head_length - 1;
1565 #define UTF8_COMPUTE(Char, Mask, Len) \
1571 else if ((Char & 0xe0) == 0xc0) \
1576 else if ((Char & 0xf0) == 0xe0) \
1581 else if ((Char & 0xf8) == 0xf0) \
1586 else if ((Char & 0xfc) == 0xf8) \
1591 else if ((Char & 0xfe) == 0xfc) \
1606 #define UTF8_LENGTH(Char) \
1607 ((Char) < 0x80 ? 1 : \
1608 ((Char) < 0x800 ? 2 : \
1609 ((Char) < 0x10000 ? 3 : \
1610 ((Char) < 0x200000 ? 4 : \
1611 ((Char) < 0x4000000 ? 5 : 6)))))
1622 #define UTF8_GET(Result, Chars, Count, Mask, Len) \
1623 (Result) = (Chars)[0] & (Mask); \
1624 for ((Count) = 1; (Count) < (Len); ++(Count)) \
1626 if (((Chars)[(Count)] & 0xc0) != 0x80) \
1632 (Result) |= ((Chars)[(Count)] & 0x3f); \
1645 #define UNICODE_VALID(Char) \
1646 ((Char) < 0x110000 && \
1647 (((Char) & 0xFFFFF800) != 0xD800))
1699 while (i < real->len)
1701 if (real->
str[i] ==
'\r')
1703 if ((i+1) < real->
len && real->
str[i+1] ==
'\n')
1720 else if (real->
str[i] ==
'\n')
1773 if (*substr ==
'\0')
1783 if (real->
str[i] == substr[0])
1789 if (substr[j - i] ==
'\0')
1791 else if (real->
str[j] != substr[j - i])
1797 if (substr[j - i] ==
'\0')
1835 while (i < real->len)
1837 if (real->
str[i] ==
' ' ||
1838 real->
str[i] ==
'\t')
1873 while (i < real->len)
1907 while (i < real->len)
1980 _dbus_assert (eol == _dbus_string_get_length (source));
2006 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
2014 _dbus_string_delete_first_word (
DBusString *str)
2025 #ifdef DBUS_ENABLE_EMBEDDED_TESTS
2032 _dbus_string_delete_leading_blanks (
DBusString *str)
2076 const unsigned char *ap;
2077 const unsigned char *bp;
2078 const unsigned char *a_end;
2084 if (real_a->
len != real_b->
len)
2089 a_end = real_a->
str + real_a->
len;
2120 const unsigned char *ap;
2121 const unsigned char *bp;
2122 const unsigned char *a_end;
2128 if (real_a->
len != real_b->
len &&
2129 (real_a->
len < len || real_b->
len < len))
2134 a_end = real_a->
str + MIN (real_a->
len, len);
2170 const unsigned char *ap;
2171 const unsigned char *bp;
2172 const unsigned char *a_end;
2184 if (a_len > real_b->
len - b_start)
2187 ap = real_a->
str + a_start;
2188 bp = real_b->
str + b_start;
2215 const unsigned char *ap;
2216 const unsigned char *bp;
2217 const unsigned char *a_end;
2223 bp = (
const unsigned char*) c_str;
2224 a_end = real_a->
str + real_a->
len;
2225 while (ap != a_end && *bp)
2234 if (ap != a_end || *bp)
2251 const unsigned char *ap;
2252 const unsigned char *bp;
2253 const unsigned char *a_end;
2259 bp = (
const unsigned char*) c_str;
2260 a_end = real_a->
str + real_a->
len;
2261 while (ap != a_end && *bp)
2288 char word_separator)
2297 data = _dbus_string_get_const_data (a);
2298 next_char = data[strlen (c_str)];
2299 return next_char ==
'\0' || next_char == word_separator;
2314 const char hexdigits[16] = {
2315 '0',
'1',
'2',
'3',
'4',
'5',
'6',
'7',
'8',
'9',
2316 'a',
'b',
'c',
'd',
'e',
'f'
2320 hexdigits[(byte >> 4)]))
2324 hexdigits[(byte & 0x0f)]))
2327 _dbus_string_get_length (str) - 1);
2351 const unsigned char *p;
2352 const unsigned char *end;
2355 _dbus_assert (start <= _dbus_string_get_length (source));
2362 p = (
const unsigned char*) _dbus_string_get_const_data (source);
2363 end = p + _dbus_string_get_length (source);
2402 const unsigned char *p;
2403 const unsigned char *end;
2407 _dbus_assert (start <= _dbus_string_get_length (source));
2415 p = (
const unsigned char*) _dbus_string_get_const_data (source);
2416 end = p + _dbus_string_get_length (source);
2494 len = _dbus_string_get_length (&result);
2496 b = _dbus_string_get_byte (&result, len - 1);
2500 _dbus_string_set_byte (&result, len - 1, b);
2503 high_bits = !high_bits;
2513 *end_return = p - (
const unsigned char*) _dbus_string_get_const_data (source);
2540 const unsigned char *s;
2541 const unsigned char *end;
2547 if (len > real->
len - start)
2550 s = real->
str + start;
2554 if (_DBUS_UNLIKELY (!_DBUS_ISASCII (*s)))
2583 s = real->
str + start;
2588 if (*s >=
'A' && *s <=
'Z')
2614 s = real->
str + start;
2619 if (*s >=
'a' && *s <=
'z')
2645 const unsigned char *p;
2646 const unsigned char *end;
2660 if (_DBUS_UNLIKELY (len > real->
len - start))
2663 p = real->
str + start;
2668 int i, mask, char_len;
2669 dbus_unichar_t result;
2689 if (_DBUS_UNLIKELY (char_len == 0))
2693 if (_DBUS_UNLIKELY ((end - p) < char_len))
2696 UTF8_GET (result, p, i, mask, char_len);
2699 if (_DBUS_UNLIKELY (
UTF8_LENGTH (result) != char_len))
2703 if (_DBUS_UNLIKELY (result == (dbus_unichar_t)-1))
2719 if (_DBUS_UNLIKELY (p != end))
2743 const unsigned char *s;
2744 const unsigned char *end;
2750 if (len > real->
len - start)
2753 s = real->
str + start;
2757 if (_DBUS_UNLIKELY (*s !=
'\0'))
#define DBUS_IS_ASCII_WHITE(c)
Checks for ASCII whitespace byte.
dbus_bool_t _dbus_string_insert_bytes(DBusString *str, int i, int n_bytes, unsigned char byte)
Inserts a number of bytes of a given value at the given position.
dbus_bool_t _dbus_string_append(DBusString *str, const char *buffer)
Appends a nul-terminated C-style string to a DBusString.
void _dbus_string_copy_to_buffer(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
#define NULL
A null pointer, defined appropriately for C or C++.
dbus_bool_t _dbus_string_equal(const DBusString *a, const DBusString *b)
Tests two DBusString for equality.
dbus_bool_t _dbus_string_find_eol(const DBusString *str, int start, int *found, int *found_len)
Finds end of line ("\r\n" or "\n") in the string, returning TRUE and filling in the byte index where ...
dbus_bool_t _dbus_string_lengthen(DBusString *str, int additional_length)
Makes a string longer by the given number of bytes.
#define ASSIGN_4_OCTETS(p, octets)
assign 4 bytes from one string to another
unsigned int valid
DBusString is valid (initialized and not freed)
void dbus_free(void *memory)
Frees a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void _dbus_string_copy_to_buffer_with_nul(const DBusString *str, char *buffer, int avail_len)
Copies the contents of a DBusString into a different buffer.
dbus_bool_t _dbus_string_hex_encode(const DBusString *source, int start, DBusString *dest, int insert_at)
Encodes a string in hex, the way MD5 and SHA-1 are usually encoded.
#define ASSIGN_8_OCTETS(p, octets)
assign 8 bytes from one string to another
dbus_bool_t _dbus_string_starts_with_c_str(const DBusString *a, const char *c_str)
Checks whether a string starts with the given C string.
void _dbus_string_chop_white(DBusString *str)
Deletes leading and trailing whitespace.
dbus_bool_t _dbus_string_insert_8_aligned(DBusString *str, int insert_at, const unsigned char octets[8])
Inserts 8 bytes aligned on an 8 byte boundary with any alignment padding initialized to 0...
void _dbus_string_tolower_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to lower case.
#define DBUS_CONST_STRING_PREAMBLE(str)
Checks assertions about a string that may be const or locked.
dbus_bool_t _dbus_string_starts_with_words_c_str(const DBusString *a, const char *c_str, char word_separator)
Checks whether a string starts with the given C string, after which it ends or is separated from the ...
char * _dbus_string_get_data_len(DBusString *str, int start, int len)
Gets a sub-portion of the raw character buffer from the string.
#define _DBUS_STRING_MAX_LENGTH
The maximum length of a DBusString.
dbus_bool_t _dbus_string_init(DBusString *str)
Initializes a string.
dbus_bool_t _dbus_string_append_printf_valist(DBusString *str, const char *format, va_list args)
Appends a printf-style formatted string to the DBusString.
void _dbus_string_shorten(DBusString *str, int length_to_remove)
Makes a string shorter by the given number of bytes.
dbus_bool_t _dbus_string_copy(const DBusString *source, int start, DBusString *dest, int insert_at)
Like _dbus_string_move(), but does not delete the section of the source string that's copied to the d...
dbus_bool_t _dbus_string_find(const DBusString *str, int start, const char *substr, int *found)
Finds the given substring in the string, returning TRUE and filling in the byte index where the subst...
void _dbus_string_skip_white(const DBusString *str, int start, int *end)
Skips whitespace from start, storing the first non-whitespace in *end.
#define ASSIGN_2_OCTETS(p, octets)
assign 2 bytes from one string to another
dbus_bool_t _dbus_string_move(DBusString *source, int start, DBusString *dest, int insert_at)
Moves the end of one string into another string.
void * dbus_malloc(size_t bytes)
Allocates the given number of bytes, as with standard malloc().
dbus_bool_t _dbus_string_equal_c_str(const DBusString *a, const char *c_str)
Checks whether a string is equal to a C string.
dbus_bool_t _dbus_string_compact(DBusString *str, int max_waste)
Compacts the string to avoid wasted memory.
dbus_bool_t _dbus_string_copy_data(const DBusString *str, char **data_return)
Copies the data from the string into a char*.
dbus_uint32_t dbus_bool_t
A boolean, valid values are TRUE and FALSE.
void _dbus_string_init_const(DBusString *str, const char *value)
Initializes a constant string.
#define DBUS_GENERIC_STRING_PREAMBLE(real)
Checks a bunch of assertions about a string object.
dbus_bool_t _dbus_string_replace_len(const DBusString *source, int start, int len, DBusString *dest, int replace_at, int replace_len)
Replaces a segment of dest string with a segment of source string.
#define DBUS_STRING_PREAMBLE(str)
Checks assertions about a string object that needs to be modifiable - may not be locked or const...
void _dbus_string_skip_blank(const DBusString *str, int start, int *end)
Skips blanks from start, storing the first non-blank in *end (blank is space or tab).
dbus_bool_t _dbus_string_pop_line(DBusString *source, DBusString *dest)
Assigns a newline-terminated or \r\n-terminated line from the front of the string to the given dest s...
#define UTF8_GET(Result, Chars, Count, Mask, Len)
Gets a UTF-8 value.
void _dbus_string_delete(DBusString *str, int start, int len)
Deletes a segment of a DBusString with length len starting at start.
dbus_bool_t _dbus_string_init_preallocated(DBusString *str, int allocate_size)
Initializes a string that can be up to the given allocation size before it has to realloc...
int len
Length without nul.
dbus_bool_t _dbus_string_append_printf(DBusString *str, const char *format,...)
Appends a printf-style formatted string to the DBusString.
#define UNICODE_VALID(Char)
Check whether a Unicode (5.2) char is in a valid range.
void _dbus_string_zero(DBusString *str)
Clears all allocated bytes in the string to zero.
dbus_bool_t _dbus_string_validate_utf8(const DBusString *str, int start, int len)
Checks that the given range of the string is valid UTF-8.
dbus_bool_t _dbus_string_align_length(DBusString *str, int alignment)
Align the length of a string to a specific alignment (typically 4 or 8) by appending nul bytes to the...
dbus_bool_t _dbus_string_equal_substring(const DBusString *a, int a_start, int a_len, const DBusString *b, int b_start)
Tests two sub-parts of two DBusString for equality.
dbus_bool_t _dbus_string_equal_len(const DBusString *a, const DBusString *b, int len)
Tests two DBusString for equality up to the given length.
unsigned int locked
DBusString has been locked and can't be changed.
#define _dbus_assert_not_reached(explanation)
Aborts with an error message if called.
dbus_bool_t _dbus_string_init_from_string(DBusString *str, const DBusString *from)
Initializes a string from another string.
dbus_bool_t _dbus_string_insert_byte(DBusString *str, int i, unsigned char byte)
Inserts a single byte at the given position.
dbus_bool_t _dbus_string_append_byte(DBusString *str, unsigned char byte)
Appends a single byte to the string, returning FALSE if not enough memory.
void _dbus_string_free(DBusString *str)
Frees a string created by _dbus_string_init(), and fills it with the same contents as #_DBUS_STRING_I...
#define TRUE
Expands to "1".
int allocated
Allocated size of data.
#define DBUS_IS_ASCII_BLANK(c)
Checks for ASCII blank byte.
#define _dbus_assert(condition)
Aborts with an error message if the condition is false.
dbus_bool_t _dbus_string_find_blank(const DBusString *str, int start, int *found)
Finds a blank (space or tab) in the string.
dbus_bool_t _dbus_string_alloc_space(DBusString *str, int extra_bytes)
Preallocate extra_bytes such that a future lengthening of the string by extra_bytes is guaranteed to ...
dbus_bool_t _dbus_string_hex_decode(const DBusString *source, int start, int *end_return, DBusString *dest, int insert_at)
Decodes a string from hex encoding.
unsigned int align_offset
str - align_offset is the actual malloc block
dbus_bool_t _dbus_string_append_byte_as_hex(DBusString *str, unsigned char byte)
Appends a two-character hex digit to a string, where the hex digit has the value of the given byte...
dbus_bool_t _dbus_string_append_len(DBusString *str, const char *buffer, int len)
Appends block of bytes with the given length to a DBusString.
dbus_bool_t _dbus_string_find_to(const DBusString *str, int start, int end, const char *substr, int *found)
Finds the given substring in the string, up to a certain position, returning TRUE and filling in the ...
#define UTF8_COMPUTE(Char, Mask, Len)
computes length and mask of a unicode character
#define UTF8_LENGTH(Char)
computes length of a unicode character in UTF-8
unsigned char * str
String data, plus nul termination.
dbus_bool_t _dbus_string_validate_nul(const DBusString *str, int start, int len)
Checks that the given range of the string is all nul bytes.
#define FALSE
Expands to "0".
dbus_bool_t _dbus_string_insert_4_aligned(DBusString *str, int insert_at, const unsigned char octets[4])
Inserts 4 bytes aligned on a 4 byte boundary with any alignment padding initialized to 0...
void _dbus_string_skip_white_reverse(const DBusString *str, int end, int *start)
Skips whitespace from end, storing the start index of the trailing whitespace in *start.
#define DBUS_LOCKED_STRING_PREAMBLE(str)
Checks assertions about a string object that may be locked but can't be const.
dbus_bool_t _dbus_string_set_length(DBusString *str, int length)
Sets the length of a string.
dbus_bool_t _dbus_string_insert_2_aligned(DBusString *str, int insert_at, const unsigned char octets[2])
Inserts 2 bytes aligned on a 2 byte boundary with any alignment padding initialized to 0...
dbus_bool_t _dbus_string_copy_len(const DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_copy(), but can copy a segment from the middle of the source string.
dbus_bool_t _dbus_string_steal_data(DBusString *str, char **data_return)
Like _dbus_string_get_data(), but removes the gotten data from the original string.
void * dbus_realloc(void *memory, size_t bytes)
Resizes a block of memory previously allocated by dbus_malloc() or dbus_malloc0().
void _dbus_string_toupper_ascii(const DBusString *str, int start, int len)
Converts the given range of the string to upper case.
int _dbus_printf_string_upper_bound(const char *format, va_list args)
Measure the length of the given format string and arguments, not including the terminating nul...
dbus_bool_t _dbus_string_insert_alignment(DBusString *str, int *insert_at, int alignment)
Inserts padding at *insert_at such to align it to the given boundary.
dbus_bool_t _dbus_string_validate_ascii(const DBusString *str, int start, int len)
Checks that the given range of the string is valid ASCII with no nul bytes.
void _dbus_string_init_const_len(DBusString *str, const char *value, int len)
Initializes a constant string with a length.
dbus_bool_t _dbus_string_move_len(DBusString *source, int start, int len, DBusString *dest, int insert_at)
Like _dbus_string_move(), but can move a segment from the middle of the source string.
unsigned int constant
String data is not owned by DBusString.
dbus_bool_t _dbus_string_append_strings(DBusString *str, char **strings, char separator)
Append vector with strings connected by separator.
dbus_bool_t _dbus_string_split_on_byte(DBusString *source, unsigned char byte, DBusString *tail)
Looks for the first occurance of a byte, deletes that byte, and moves everything after the byte to th...
#define DBUS_STRING_COPY_PREAMBLE(source, start, dest, insert_at)
Checks assertions for two strings we're copying a segment between, and declares real_source/real_dest...